21-StrutsBasics 122

03/01/2006
Struts Basics
The goal of this session is to learn the basic concept of Struts and its architecture.
03/01/2006
Sang Shin
sang.shin@sun.com www.javapassion.com Technology Evangelist Java Sun Microsystems, Inc.
2
03/01/2006
Disclaimer & Acknowledgments

? ? ?
Even though Sang Shin is a full-time employees of Sun Microsystems, the contents here are created as their own personal endeavor and thus does not reflect any official stance of Sun Microsystems. Sun Microsystems is not responsible for any inaccuracies in the contents. Acknowledgments: I borrowed from presentation slides from the following sources
? ?
Struts presentation by Roger W Barnes of Project Refinery, Inc. Pictures from Struts 1.1 presentation by Chuck Cavaness
Struts' user's guide is also used in creating slides and speaker notes Source code examples are from Keld Hansen
03/01/2006
Revision History
? ?
11/10/2003: version 1: created by Sang Shin 09/03/2005: Struts tags and tools sections are moved to different presentation slides Things to do Speaker notes need to be added to some slides Contents still need to be polished
03/01/2006
Agenda
? ?
What is and Why Struts? Struts architecture

Controller: Focus of this presentation Model View
? ? ?
Struts tag library (moved to StrutsTags presentation) Internationalization Validation and error handling View selection
5
This is the agenda. We will learn first what is and why Struts. Then we will look into Struts architecture as one that follows MVC pattern. Struts comes with extensive tag library so we will learn how to use them. We will also learn how internationalization is done in Struts. We will learn how input form validation and error handling can be done. At the end, I will talk about Struts console tool that you can use to graphically edit Struts configuration file.
03/01/2006
What is Struts?
So what is Struts?
03/01/2006
Jakarta Struts
?
Struts is an open source Web application framework developed as Apache Jakarta project
http://jakarta.apache.org/struts/
I assume most of you know Struts is an open source web application framework developed as Apache Jakarta project.
03/01/2006
What is Struts?
? ?
Model-View-Controller (MVC) framework Used for constructing web applications using Servlets and JSPs
Struts application is a genuine Web application that should be able to run on any Sevlet container including all J2EE compliant App servers Singleton, composition view, delegate Easy to use and learn
Pattern oriented

Includes JSP custom tag libraries

8
Let me give you a quick high-level overview on what Struts is from a technical standpoint. Struts is based on MVC (Model View Controller) framework. It is used to build Web applications based on Servlet and JSP. So Struts application is a genuine Web application. Struts leverages J2EE design patterns that people find quite useful in building J2EE applications. Because Struts follows these patterns including MVC, Struts is relatively simple to use and learn. A Composite View is a view built using other reusable subviews. A single change to a sub-view is automatically reflected in every composite view that uses it. Furthermore, the composite view manages the layout of its sub-views and can provide a template, making consistent look and feel feel easier to achieve and modify across the entire application. Struts has its own set of custom tag libraries. Struts also support utility classes.
03/01/2006
Struts allows Web Application Developers to ...

?
Fashion their JSP/Servlet web applications using the MVC design pattern Leverage ready-to-usable framework objects through xml configuration files Leverage built-in design patterns in the framework Leverage extra features such as input validation, internationalization
9
So why do you want to use Struts as a Web application developer? There are a few reasons. First, it let you fashion your JSP/Servlet applications to use MVC design pattern. Since we talked about what and why you want to use MVC design pattern in previous class, I am not going to talk about it here. Struts also leverages ready-to-usable framework objects such as Action class or ActionMapping through XML configuration files. And we will talk about these framework objects in detail in the later part of this presentation. Struts also leverages time-proven design patterns internally in the framework. So you don't have to create your design patterns.
03/01/2006
Why Struts?
10
Now let's talk about benefits of using Struts in a bit more detail.
03/01/2006
Why Struts?
?
? ? ? ? ? ? ? ?
Takes much of the complexity out of building your own MVC framework Encourages good design practice and modeling Easy to learn and use Feature-rich Many supported 3rd-party tools Flexible and extensible Large user community Stable and mature Open source 11
So we all know that we want to build our Web applications based on MVC framework. (We talked about why you want to use MVC pattern in MVC framework presentation.) Now instead of building your own MVC framework, you can use Struts. Struts also encourages good design practices and modeling because the framework is designed with time-proven design patterns. Struts is relatively simple, thus is easy to learn and use. It also support many useful features such as internationalization and input validation. Another reason why Struts has garnered so much popularity among developers is there are many 3rd-party tools. Struts is designed to be extensible and flexible. In fact, as will talk about in advanced Struts presentation, Struts, especially Struts 1.1, let you extend and customize the framework if the default framework for some reason does not meet the needs. Ever since it is introduced, Struts enjoyed a very large following from Java developer community. Struts has been around quite a while and is considered very stable and mature. And of course, being a open source project helps Struts' adoption.
03/01/2006
Why Struts?
? ? ? ? ?
? ?
Integrates well with J2EE Good taglib support Works with existing web apps Easy to retain form state Unified error handling programmatically and declaratively Integration with Tiles framework Clear delineation of responsibility makes long term maintenance easier (more modular)
12
Struts is very well integrated with J2EE. For example, many people use Struts as Web-tier framework in which model objects can be implemented in the form of EJB. Struts provides good tag libraries. It is relatively easy to adapt existing Web applications to the Struts framework. Struts allows capturing input form data into JavaBean objects called ActionForms. It also provides standard error handling both programatically and declaratively. And as we will see in advanced Struts presentation, Struts is well integrated with Tiles framework in which Struts application can leverage flexible and pluggable layout management.
03/01/2006
Struts Architecture (Quick Overview)

13
03/01/2006
Model-View-Control (model 2)
MVC Design Pattern 1
Request
(Controller) Servlet
This is a rehash of what we learned in MVC pattern and framework session. A Model 2 architecture introduces a controller servlet between the browser and the JSP pages. The controller centralizes the logic for dispatching requests to the next view based on the request URL, input parameters, and application state. The controller also handles view selection, which de-couples JSP pages and servlets from one another. Model 2 applications are easier to maintain and extend, because views do not refer to each other directly. The Model 2 controller servlet provides a single point of control for security and logging, and often encapsulates incoming data into a form usable by the back-end MVC model. For these reasons, the Model 2 architecture is recommended for most web applications.
BROWSER
5
Response
te tia tan Ins
Redirect
(View) JSP
(Model) Java Bean
Servlet Container
(EIS)
14
03/01/2006
How Struts Works
15
When initialized, the controller parses a configuration file (struts-config.xml) and uses it to deploy other control layer objects. Together, these objects form the Struts Configuration. The Struts Configuration defines (among other things) the ActionMappings [org.apache.struts.action.ActionMappings] for an application. The Struts controller servlet consults the ActionMappings as it routes HTTP requests to other components in the framework. Requests may be forwarded to JavaServer Pages or Action [org.apache.struts.action.Action] subclasses provided by the Struts developer. Often, a request is first forwarded to an Action and then to a JSP (or other presentation page). The mappings help the controller turn HTTP requests into application actions. The Action object can handle the request from and respond to the client (usually a Web browser) or indicate that control should be forwarded elsewhere. For example, if a login succeeds, a login action may wish to forward the request onto the mainMenu page. Action objects have access to the application's controller servlet, and so have access to that servlet's methods. When forwarding control, an Action object can indirectly forward one or more shared objects, including JavaBeans, by placing them in one of the standard contexts shared by Java Servlets.
03/01/2006
Struts: MVC-based Architecture

?
? ? ?
Central controller mediates application flow and delegates to appropriate handler called Action Action Handlers can use model components Model encapsulates business logic or state Control forwarded back through the Controller to the appropriate View
The forwarding can be determined by consulting a set of mappings in configuration file, which provides a loose coupling between the View and Model
16
In the MVC design pattern, application flow is mediated by a central Controller. The Controller delegates requests - in our case, HTTP requests - to an appropriate handler. As we will talk about in detail later on, these handlers are called Actions. The handlers can use Model components, and in a sense each handler acts as an adapter between the request and the Model. The Model represents, or encapsulates, an application's business logic or state. Once handler handles the request, the control is usually then forwarded back through the Controller to the appropriate View. The forwarding can be determined by consulting a set of mappings, which is defined by Struts configuration file. This configuration file based forwarding provides a loose coupling between the View and Model, which can make applications significantly easier to create and maintain.
03/01/2006

?
3 Major Components in Struts

Servlet controller (Controller) Java Server Pages or any other presentation technology (View) Application Business Logic in the form of whatever suits the application (Model) Struts is Model and View independent Struts can use any Model and View technologies
17
Struts is focused on Controller

So the three major components of Struts are ActionServlet which functions as a controller. Java Server Pages and any other presentations technologies that function as View and Application business logic in the form of whatever suites the application which functions as Model. Now the most important key component of Struts is controller. That is, the Struts framework has a concrete set of programming API's and classes for Controller functions while Struts does not dictate any Model or View technologies. In fact, it is said that Struts is model and view independent because Struts allow any kind of View and Model technologies.
03/01/2006

?
Configuration file contains action mappings

URL to Action mappings Controller uses these mappings to turn HTTP requests into application actions Determines forwarding/navigation A request path Action to act upon the request
18
Mapping must specify

So let's rehash the point that Struts is MVC pattern based architecture one more time. In Struts, a configuration file calles struts-config.xml contains so called Action mappings. These action mappings specifies mappings between URL and Actions. That is, controller uses these mappings to turn HTTP requests into application actions. The action mappings also determines forwarding and navigation depending the outcome of the Actions. So each mapping must specify request path and action to act upon the request. Now please don't worry if you don't understand what I've talked about so far on Struts. We will look into these using detailed examples in the rest of the presentation.
03/01/2006
Controller
19
So let's talk about Controller piece of the Struts.
03/01/2006
What does Controller do?

? ? ?
Is the switch board of MVC architecture Every request goes through the controller Responsible for flow control (action mapping) of the request handling
reads configuration file to determine the flow control
20
The Controller piece of MVC architecture is focused on receiving requests from the client (typically a user running a web browser), deciding what business logic function is to be performed, and then delegating responsibility for producing the next phase of the user interface to an appropriate View component depending on the outcome of the business logic function. Again, the controller does all these by reading configuration file.
03/01/2006
source: Chuck Cavaness
21
In Struts, the primary component of the Controller is a servlet class called ActionServlet. So the term ActionServlet and controller is used interchangeably in Struts. (In Struts 1.1, the majority of controller functionality is moved to what is called RequestProcessor.) The ActionServlet reads a set of ActionMappings from the configuration file. An ActionMapping defines a path that is matched against the request URI of the incoming request, and usually specifies the fully qualified class name of an Action class. All Actions are subclassed from org.apache.struts.action.Action. Actions then calls Model objects which in turn handles the business logic. The Actions then interpret the result of the business logic and generates an outcome. Based on this outcome, the controller then dispatches control to the appropriate View component to create the response.
03/01/2006
Controller in Struts Framework

?
Struts framework provides a built-in base servlet

org.apache.struts.action.ActionServlet Servlet mapping has to be configured in web.xml
Struts related configuration is done through struts-config.xml
Action Mapping defines the mapping between request URI of incoming requests to specific Action class
22
03/01/2006
Developer Responsibility
?
Write an Action class (that is, an extension of the Action class) for each logical request that may be received
override execute() method (perform() method in Struts 1.0) struts-config.xml
Write the action mapping configuration file
Update the web application deployment descriptor file to specify the ActionServlet
web.xml
23
03/01/2006
Controller Components in Struts Framework

? ?
ActionServlet (Provided by Struts) RequestProcessor (Struts 1.1)(Provided by Struts)
One for each module Developer extends Struts-provided Action class Developer specifies action mapping in struts-config.xml file Struts framework creates ActionMapping object and passes it to Action object
24
Action (Provided by developer)
Action Mapping (Specified by developer)

In Struts, the primary component of the Controller is a servlet of class ActionServlet. This servlet is configured by defining a set of ActionMappings. An ActionMapping defines a path that is matched against the request URI of the incoming request, and usually specifies the fully qualified class name of an Action class. All Actions are subclassed from org.apache.struts.action.Action. Actions encapsulate the business logic, interpret the outcome, and ultimately dispatch control to the appropriate View component to create the response. Struts also supports the ability to use ActionMapping classes that have additional properties beyond the standard ones required to operate the framework. This allows you to store additional information specific to your application, but still utilize the remaining features of the framework. In addition, Struts lets you define logical "names" to which control should be forwarded so that an action method can ask for the "Main Menu" page (for example), without knowing what the actual name of the corresponding JSP page is. These features greatly assist you in separating the control logic (what to do) with the view logic (how it's rendered).
03/01/2006
ActionServlet
(Provided by Framework)
25
03/01/2006
What Does ActionServlet Do?

?
Performs the role of Controller

Process user requests Determine what the user is trying to achieve according to the request Pull data from the model (if necessary) to be given to the appropriate view, and Select the proper view to respond to the user
Delegates most of this grunt work to Action classes

26
For those of you familiar with MVC architecture, the ActionServlet represents the C - the controller. The job of the controller is to: # process user requests, # determine what the user is trying to achieve according to the request, # pull data from the model (if necessary) to be given to the appropriate view, and # select the proper view to respond to the user. The Struts controller delegates most of this grunt work to Action classes.
03/01/2006
What Does ActionServlet Do? (Continued)

?
Is responsible for initialization and clean-up of resources

loads the application config corresponding to the "config" init-param's in web.xml goes through an enumeration of all init-param elements, looking for those elements who's name starts with config/ for modules To access the module foo, you would use a URL like:
?
http://localhost:8080/myApp/foo/someAction.do
27
In addition to being the controller for your application, the ActionServlet instance also is responsible for initialization and clean-up of resources. When the controller initializes, it first loads the application config corresponding to the "config" init-param. It then goes through an enumeration of all init-param elements, looking for those elements who's name starts with config/. For each of these elements, Struts loads the configuration file specified by the value of that init-param, and assigns a "prefix" value to that module's ModuleConfig instance consisting of the piece of the init-param name following "config/". For example, the module prefix specified by the init-param config/foo would be "foo". This is important to know, since this is how the controller determines which module will be given control of processing the request. To access the module foo, you would use a URL like: http://localhost:8080/myApp/foo/someAction.do For each request made of the controller, the method process (HttpServletRequest, HttpServletResponse) will be called. This method simply determines which module should service the request and then invokes that module's RequestProcessor's process method, passing the same request and response.
03/01/2006
Flow control by Controller
28
03/01/2006
Struts Flow (Struts 1.0)

Http://myhost/authorize.do
Server configured to pass *.do extensions to org.apache.struts.action.ActionServlet via a web.xml configuration file
ActionServlet object inspects the URI and tries to match it against an ActionMapping located in the struts-config.xml file
Instance of appropriate Action class is found and its execute() is called. Action object handles the request and returns a next view. View is identified by ActionForward objerct.
29
ActionServlet uses a configuration file called struts-config.xml to read mapping data called action mappings ActionServlet class reads the incoming URI and tries to match the URI against a set of action mappings to see if it can find a controller class which would be willing to handle the request This process is described in a diagram on the following page
03/01/2006
RequestProcessor
(Provided by Framework)
30
The RequestProcessor is where the majority of the core processing occurs for each request. Let's take a look at the helper functions the process method invokes in-turn:
03/01/2006
What Does RequestProcessor Do?

?
processPath
Determine the path that invoked us. This will be used later to retrieve an ActionMapping. Select a locale for this request, if one hasn't already been selected, and place it in the request. Set the default content type (with optional character encoding) for all responses if requested.
31
processLocale
processContent
(read slide)
03/01/2006

?
processNoCache
If appropriate, set the following response headers: "Pragma", "Cache-Control", and "Expires". This is one of the "hooks" the RequestProcessor makes available for subclasses to override. The default implementation simply returns true. If you subclass RequestProcessor and override processPreprocess you should either return true (indicating process should continue processing the request) or false (indicating you have handled the request and the process should return)
32
processPreprocess
(read slide)
03/01/2006

?
processMapping
Determine the ActionMapping associated with this path. If the mapping has a role associated with it, ensure the requesting user is has the specified role. If they do not, raise an error and stop processing of the request. Instantiate (if necessary) the ActionForm associated with this mapping (if any) and place it into the appropriate scope.
processRoles
processActionForm
33
(read slide)
03/01/2006

?
processPopulate
Populate the ActionForm associated with this request, if any. Perform validation (if requested) on the ActionForm associated with this request (if any). If this mapping represents a forward, forward to the path specified by the mapping.
processValidate
processForward
34
(read slide)
03/01/2006

?
processInclude
If this mapping represents an include, include the result of invoking the path in this request. Instantiate an instance of the class specified by the current ActionMapping (if necessary). This is the point at which your action's perform() or execute() method will be called.
processActionCreate
processActionPerform
35
(read slide)
03/01/2006

?
processForwardConfig
Finally, the process method of the RequestProcessor takes the ActionForward returned by your Action class, and uses to select the next resource (if any). Most often the ActionForward leads to the presentation page that renders the response.
36
(read slide)
03/01/2006
Action Mapping (You provide it)

37
03/01/2006
Action Mapping in Struts Config File

?
Struts controller ActionServlet needs to know several things about how each request URI should be mapped to an appropriate Action class These requirements are encapsulated in a Java interface named ActionMapping
Struts framework creates ActionMapping object from <ActionMapping> configuration element of struts-config.xml file
38
The developer's responsibility is to create an XML file named strutsconfig.xml and place it in the WEB-INF directory of your application. This format of this document is described by the Document Type Definition (DTD) maintained at http://jakarta.apache.org/struts/dtds/strutsconfig_1_1.dtd. This chapter covers the configuration elements that you will typically write as part of developing your application. There are several other elements that can be placed in the struts-config file to customize your application. The controller uses an internal copy of this document to parse the configuration; an Internet connection is not required for operation.
03/01/2006
Struts Config File (struts-config.xml)

?
struts-config.xml contains three important elements used to describe actions:

<form-beans> contains FormBean definitions including name and type (classname) <action-mapping> contains action definitions
?
Use an <action> element for each action defined
<global-forwards> contains your global forward definitions
39
The outermost XML element must be <struts-config>. Inside of the <struts-config> element, there are three important elements that are used to describe your actions: * <form-beans> * <global-forwards> * <action-mappings>
03/01/2006

?
<form-beans>

This section contains your form bean definitions. You use a <form-bean> element for each form bean, which has the following important attributes:
?
name: The name of the request (and session level attribute that this form bean will be stored as) type: The fully-qualified Java classname of your form bean
40
<form-bean> section section contains your form bean definitions. Form beans are descriptors that are used to create ActionForm instances at runtime. You use a <form-bean> element for each form bean, which has the following important attributes: * name: A unique identifier for this bean, which will be used to reference it in corresponding action mappings. Usually, this is also the name of the request or session attribute under which this form bean will be stored. * type: The fully-qualified Java classname of the ActionForm subclass to use with this form bean.
03/01/2006
struts-config.xml: <form-beans> from struts-submit application

1 <?xml version="1.0" encoding="ISO-8859-1" ?>
2 3 <!DOCTYPE struts-config PUBLIC 4 "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" 5 "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"> 6 7 <struts-config> 8 9  10 <form-beans> 11 12 <form-bean name="submitForm" 13 type="submit.SubmitForm"/> 14 15 </form-beans>
41
03/01/2006

?
<action-mappings>
This section contains your action definitions. You use an <action> element for each of your actions you would like to define.
42
<action-mapping> section contains your action definitions. You use an <action> element for each of the mappings you would like to define.
03/01/2006

?
<action-mappings>
Each <action> element requires the following attributes to be defined:

?
? ?
path: The application context-relative path to the action (URI of the request) type: The fully qualified java classname of your Action class name: The name of your <form-bean> element to use with this action input: The name of the display page when input form validation error condition occurs scope: The scope in which form bean is created validate: Whether to perform input form validation or not 43
Most action elements will define at least the following attributes: * path: The application context-relative path to the action. * type: The fully qualified java classname of your Action class. * name: The name of your <form-bean> element to use with this action Other often-used attributes include: * parameter: A general-purpose attribute often used by "standard" Actions to pass a required property. * roles: A comma-delimited list of the user security roles that can access this mapping.
03/01/2006
struts-config.xml: <action-mappings> from struts-submit application

1  2 <action-mappings> 3 4 <action path="/submit" 5 type="submit.SubmitAction" 6 name="submitForm" 7 input="/submit.jsp" 8 scope="request" 9 validate="true"> 10 <forward name="success" path="/submit.jsp"/> 11 <forward name="failure" path="/submit.jsp"/> 12 </action> 13 14 </action-mappings> 15 16 </struts-config>
44
03/01/2006
struts-config.xml: <action-mappings> from struts-example application

1
2 3 4 5 6 7 8 9 10 11 12 13 14
<action-mappings> <action path="/logon" type="org.apache.struts.webapp.example.LogonAction" name="logonForm" scope="request" input="/logon.jsp" validate="true" /> </action-mappings> </struts-config>
45
As you can see, this mapping matches the path /logon (actually, because the MailReader example application uses extension mapping, the request URI you specify in a JSP page would end in /logon.do). When a request that matches this path is received, an instance of the LogonAction class will be created (the first time only) and used. The controller servlet will look for a bean in request scope under key logonForm, creating and saving a bean of the specified class if needed.
03/01/2006
Action Mapping Config File

?
<global-forwards>

Forwards are instances of the ActionForward class returned from an Action's execute() method These map logical names to specific resources (typically JSPs) <forward> element has following attributes
?
? ?
name: logical name of the forward used within execute() method of Action class to forward to the next resource path: to-be-forwarded resource redirect: redirect (true) or forward (false)
46
<global-forwards> section contains your global forward definitions. Forwards are instances of the ActionForward class returned from an ActionForm's execute method. These map logical names to specific resources (typically JSPs), allowing you to change the resource without changing references to it throughout your application. You use a <forward> element for each forward definition, which has the following important attributes: * name: The logical name for this forward. This is used in your ActionForm's execute method to forward to the next appropriate resource. Example: homepage * path: The context relative path to the resource. Example: /index.jsp or / index.do * redirect: True or false (default). Should the ActionServlet redirect to the resource instead of forward?
03/01/2006
Global Forwarding
1 <struts-config>
2 3 4 5 6 7 8 9 10 11 12 13 14
<form-beans> <form-bean name="logonForm" type="org.apache.struts.webapp.example.LogonForm" /> </form-beans> <global-forwards type="org.apache.struts.action.ActionForward"> <forward name="logon" path="/logon.jsp" redirect="false" /> </global-forwards>
47
First the form bean is defined. A basic bean of class "org.apache.struts.webapp.example.LogonForm" is mapped to the logical name "logonForm". This name is used as a request attribute name for the form bean. The "global-forwards" section is used to create logical name mappings for commonly used presentation pages. Each of these forwards is available through a call to your action mapping instance, i.e. mapping.findForward("logicalName").
03/01/2006
Local Forwarding
1 
2 <action 3 path="/editSubscription" 4 type="org.apache.struts.webapp.example.EditSubscriptionAction" 5 name="subscriptionForm" 6 scope="request" 7 validate="false"> 8 <forward 9 name="failure" 10 path="/mainMenu.jsp "/> 11 <forward 12 name="success" 13 path="/subscription.jsp"/> 14 </action>
48
Optional but very useful are the local "forward" elements. In the MailReader example application, many actions include a local "success" and/or "failure" forward as part of an action mapping. Using just these two extra properties, the Action classes are almost totally independent of the actual names of the presentation pages. The pages can be renamed (for example) during a redesign, with negligible impact on the Action classes themselves. If the names of the "next" pages were hard coded into the Action classes, all of these classes would also need to be modified. Of course, you can define whatever local forward properties makes sense for your own application.
03/01/2006
ActionForm (You provide it unless you use DynaActionForm)

49
03/01/2006
ActionForm Bean (Form bean)

?
Provided by developer
Define an ActionForm bean (that is, a Java class extending the ActionForm class) for the input form Define it in struts-config.xml file ? <form-bean> ? name attribute of <Action> class
Contains only property getter and property setter methods for each field-no business logic Provides standard validation mechnism
50
While ActionForm beans often have properties that correspond to properties in your Model beans, the form beans themselves should be considered a Controller component. As such, they are able to transfer data between the Model and View layers. The Struts framework generally assumes that you have defined an ActionForm bean (that is, a Java class extending the ActionForm class) for the input forms in your application. ActionForm beans are sometimes just called "form beans". These may be finely-grained objects, so that there is one bean for each form, or coarsely-grained so that one bean serves several forms, or even an entire application.
03/01/2006
ActionForm Bean & Controller

?
For each ActionForm bean defined in servlet-config.xml file, Controller (ActionServlet) will
Check session scope for an instance of ActionForm bean ? If it does not exist, controller creates one Call corresponding setter method of ActionForm bean for every request parameter whose name corresponds to the name of a property of the bean Pass the updated ActionForm bean object as a parameter to execute() method of Action class
51
If you declare such beans in your Struts configuration file (see " Building the Controller Components"), the Struts controller servlet will automatically perform the following services for you, before invoking the appropriate Action method: * Check for an instance of a bean of the appropriate class, under the appropriate key, in the appropriate scope (request or session). * If there is no such bean instance available, a new one is automatically created and added to the appropriate scope (request or session). * For every request parameter whose name corresponds to the name of a property in the bean, the corresponding setter method will be called. This operates in a manner similar to the standard JSP action <jsp:setProperty> when you use the asterisk wildcard to select all properties. * The updated ActionForm bean will be passed to the execute method of an Action class [org.apache.struts.Action], so that the values can be made available to your system state and business logic beans.
03/01/2006
How to write ActionForm Bean

?
Add just getter and setter methods for each property of a input form
Do not include any business logic code
Add a standard validation method called validate()
Controller will call this validation
Define a property (with associated getXxx and setXxx methods) for each field that is present in the input form
52
When you code your ActionForm beans, keep the following principles in mind: * The ActionForm class itself requires no specific methods to be implemented. It is used to identify the role these particular beans play in the overall architecture. Typically, an ActionForm bean will have only property getter and property setter methods, with no business logic. * The ActionForm object also offers a standard validation mechanism. If you override a "stub" method, and provide error messages in the standard application resource, Struts will automatically validate the input from the form (using your method). See " Action Form Validation" for details. Of course, you can also ignore the ActionForm validation and provide your own in the Action object. * Define a property (with associated getXxx and setXxx methods) for each field that is present in the form. The field name and property name must match according to the usual JavaBeans conventions (see the Javadoc for the java.beans.Introspector class for a start on information about this). For example, an input field named username will cause the setUsername method to be called.
03/01/2006
Example: submit.jsp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 <%@ <%@ <%@ <%@ page language= " java " %> taglib uri= " /WEB-INF/struts-bean.tld " prefix= " bean " %> taglib uri= " /WEB-INF/struts-html.tld " prefix=" html" %> taglib uri= " /WEB-INF/struts-logic.tld " prefix= " logic" %> <html> <head><title>Submit example</title></head> <body> <h3>Example Submit Page</h3> <html:errors/> <html:form action=" submit.do " > Last Name: <html:text property= " lastName " /><br> Address: <html:textarea property= " address "/><br> Sex: <html:radio property= " sex " value=" M" />Male <html:radio property= " sex" value= " F " />Female<br> Married: <html:checkbox property= " married "/><br> Age: <html:select property= " age "> <html:option value= " a" >0-19</html:option> <html:option value= " b " >20-49</html:option> <html:option value= " c " >50-</html:option> </html:select><br> <html:submit/> </html:form>
source: Keld Hansen
53
So this slide shows submit.jsp page in which a form page prompts 5 properties - lastname, address, sex, married, age. And in the following slide, we will see how these properties are reflected as getter and setter methods of ActionForm class.
03/01/2006
Model: ActionForm
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 package submit; import javax.servlet.http.HttpServletRequest; import org.apache.struts.action.*; public final class SubmitForm extends ActionForm { /* Last Name */ private String lastName = " Hansen " ; // default value public String getLastName() { return (this.lastName); } public void setLastName(String lastName) { this.lastName = lastName; } /* Address */ private String address = null; public String getAddress() { return (this.address); } public void setAddress(String address) { this.address = address; } ...
source: Keld Hansen
54
This is an example code of ActionForm class. Here the SubmitForm extends ActionForm class. And it contains getter and setter methods for each field of an input form that are defined in the previous slide. In this slide we show getter and setter methods of only lastname and address properties.
03/01/2006
struts-config.xml: <form-beans>
1 <?xml version="1.0" encoding="ISO-8859-1" ?>
2 3 <!DOCTYPE struts-config PUBLIC 4 "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" 5 "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"> 6 7 <struts-config> 8 9  10 <form-beans> 11 12 <form-bean name="submitForm" 13 type="submit.SubmitForm"/> 14 15 </form-beans>
source: Keld Hansen
55
03/01/2006
struts-config.xml: <action-mappings>
1  2 <action-mappings> 3 4 <action path="/submit" 5 type="submit.SubmitAction" 6 name="submitForm" 7 input="/submit.jsp" 8 scope="request" 9 validate="true"> 10 <forward name="success" path="/submit.jsp"/> 11 <forward name="failure" path="/submit.jsp"/> 12 </action> 13 14 </action-mappings> 15 16 </struts-config>
source: Keld Hansen
56
03/01/2006
DynaActionForm in Struts 1.1

?
Instead of creating a new ActionForm subclass and new get/set methods for each of your bean's properties, you can list its properties, type, and defaults in the Struts configuration file
Use DanaActionForm whenever possible
We will learn more about this in Advanced Struts session
57
Maintaining a separate concrete ActionForm class for each form in your Struts application is time-consuming. It is particularly frustrating when all the ActionForm does is gather and validate simple properties that are passed along to a business JavaBean. This bottleneck can be alleviated through the use of DynaActionForm classes. Instead of creating a new ActionForm subclass and new get/set methods for each of your bean's properties, you can list its properties, type, and defaults in the Struts configuration file.
03/01/2006
Action (You create one yourself)

58
03/01/2006
59
03/01/2006
Action Class
?
Focus on control flow

Process client request by calling other objects (BusinessLogic beans) inside its execute() method Returns an ActionForward object that identifies a destination resource to which control should be forwarded to The detination resource could be
? ? ? ?
JSP Tile definition Velocity template Another Action

60
The goal of an Action class is to process a request, via its execute method, and return an ActionForward object that identifies where control should be forwarded (e.g. a JSP, Tile definition, Velocity template, or another Action) to provide the appropriate response.
03/01/2006
What is Action Class?

?
Java class that does the work of your application

Handle request Perform business logic Simple action class does handle business logic by itself Sophisticated ones delegate business logic to Model components ? Action class functions as a Facade pattern in this case
61
Can be simple or sophisticated

03/01/2006
Example Action: Logon

?
Application needs to

Authenticate a User Establish a User Session Error handling
Develop a LogonAction
62
03/01/2006
Developer Responsibility: Action Class

? ?
Extend org.jakarta.struts.action.Action Override

execute() method (in Struts 1.1) perform() method (in Struts 1.0)
63
03/01/2006
execute(..) method of Action class (Struts 1.1 only)

?
Invoked by controller
public ActionForward execute( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception;
64
Please note that the execute() method receive ActionMapping and ActionForm objects as input parameters. These two objects are created by the Struts controller. In Struts 1.0, Actions called a perform method instead of the now-preferred execute method. These methods use the same parameters and differ only in which exceptions they throw. The elder perform method throws SerlvetException and IOException. The new execute method simply throws Exception. The change was to facilitate the Declarative Exception handling feature introduced in Struts 1.1.
03/01/2006
perform(..) method of Action class (Struts 1.0 only)

?
Deprecated
public ActionForward perform( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException;
65
The perform method may still be used in Struts 1.1 but is deprecated. The Struts 1.1 method simply calls the new execute method and wraps any Exception thrown as a ServletException.
03/01/2006
execute() method of Action class

?
Perform the processing required to deal with this request Update the server-side objects (Scope variables) that will be used to create the next page of the user interface Return an appropriate ActionForward object
66
In the MVC/Model 2 design pattern, a typical Action class will often implement logic like the following in its execute method: * Validate the current state of the user's session (for example, checking that the user has successfully logged on). If the Action class finds that no logon exists, the request can be forwarded to the presentation page that displays the username and password prompts for logging on. This could occur because a user tried to enter an application "in the middle" (say, from a bookmark), or because the session has timed out, and the servlet container created a new one. * If validation is not complete, validate the form bean properties as needed. If a problem is found, store the appropriate error message keys as a request attribute, and forward control back to the input form so that the errors can be corrected. * Perform the processing required to deal with this request (such as saving a row into a database). This can be done by logic code embedded within the Action class itself, but should generally be performed by calling an appropriate method of a business logic bean. * Update the server-side objects that will be used to create the next page of the user interface (typically request scope or session scope beans, depending on how long you need to keep these items available). * Return an appropriate ActionForward object that identifies the presentation page to be used to generate this response, based on the newly updated beans. Typically, you will acquire a reference to such an object by calling findForward on either the ActionMapping object you received (if you are using a logical name local to this mapping), or on the controller servlet itself (if you are using a logical name global to the application).
03/01/2006
Example: Action Class

1 package submit; 2 3 import javax.servlet.http.*; 4 import org.apache.struts.action.*; 5 6 public final class SubmitAction extends Action { 7 8 public ActionForward execute(ActionMapping mapping, 9 ActionForm form, 10 HttpServletRequest request, 11 HttpServletResponse response) { 12 13 SubmitForm f = (SubmitForm) form; // get the form bean 14 // and take the last name value 15 String lastName = f.getLastName(); 16 // Translate the name to upper case 17 //and save it in the request object 18 request.setAttribute("lastName", lastName.toUpperCase()); 19 20 // Forward control to the specified success target 21 return (mapping.findForward("success")); 22 } 23 } 24
67
This is an example of Action class of submitHansen sample code. In this example, we just get the value of lastname property and then save it in request scope object after changing it to uppercase. And then it returns ActionForward object which is associated with success.
03/01/2006
Design Guidelines of Action Class

?
The controller Servlet creates only one instance of your Action class, and uses it for all requests

Action class has to be in multi-threaded safe Use local variables (as opposed to instanace variables) Use Model components for complex business logic handling
Make Action class a thin layer
68
Write code for a multi-threaded environment - The controller servlet creates only one instance of your Action class, and uses this one instance to service all requests. Thus, you need to write thread-safe Action classes. Follow the same guidelines you would use to write thread-safe Servlets. Here are two general guidelines that will help you write scalable, thread-safe Action classes: Only Use Local Variables - The most important principle that aids in thread-safe coding is to use only local variables, not instance variables, in your Action class. Local variables are created on a stack that is assigned (by your JVM) to each request thread, so there is no need to worry about sharing them. An Action can be factored into several local methods, so long as all variables needed are passed as method parameters. This assures thread safety, as the JVM handles such variables internally using the call stack which is associated with a single Thread. Don't throw it, catch it! - Ever used a commercial website only to have a stack trace or exception thrown in your face after you've already typed in your credit card number and clicked the purchase button? Let's just say it doesn't inspire confidence. Now is your chance to deal with these application errors - in the Action class. If your application specific code throws expections you should catch these exceptions in your Action class, log them in your application's log (servlet.log("Error message", exception)) and return the appropriate ActionForward. It is wise to avoid creating lengthy and complex Action classes. If you start to embed too much logic in the Action class itself, you will begin to find the Action class hard to understand, maintain, and impossible to reuse. Rather than creating overly complex Action classes, it is generally a good practice to move most of the persistence, and "business logic" to a separate application layer. When an Action class becomes lengthy and procedural, it may be a good time to refactor your application architecture and move some of this logic to another conceptual layer; otherwise, you may be left with an inflexible application which can only be accessed in a web-application environment. Struts should be viewed as simply the foundation for implementing MVC in your applications. Struts provides you with a useful control layer, but it is not a fully featured platform for building MVC applications, soup to nuts.
03/01/2006
Example 2: Action Class

1 package submit; 2 import javax.servlet.http.*; 3 import org.apache.struts.action.*; 4 public final class SubmitAction extends Action { 5 public ActionForward execute(ActionMapping mapping, 6 ActionForm form, 7 HttpServletRequest request, 8 HttpServletResponse response) { 9 10 SubmitForm f = (SubmitForm) form; // get the form bean 11 // and take the last name value 12 String lastName = f.getLastName(); 13 if (lastName.startsWith(Passion)){ 14 // Translate the name to upper case 15 //and save it in the request object 16 request.setAttribute("lastName", lastName.toUpperCase()); 17 // Forward control to the specified success target 18 return (mapping.findForward("success")); 19 } 20 else{ 21 return (mapping.findForward("failure")); 22 } 23 } 24 }
69
03/01/2006
struts-config.xml: ActionMapping
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17  <action-mappings> <action path="/submit" type="submit.SubmitAction" name="submitForm" input="/submit.jsp" scope="request" validate="true"> <forward name="success" path="/submitSuccess.jsp"/> <forward name="failure" path="/submitFailure.jsp"/> </action> </action-mappings> </struts-config>
70
03/01/2006
Pre-built Action Classes

? ? ?
ForwardAction DispatchAction We will learn more about these in Advanced Struts session
71
03/01/2006
Model Components (You provide them)

72
03/01/2006
Model Components
?
Model divided into concepts

Internal state of the system Business logic that can change that state JavaBeans Enterprise JavaBeans POJO's JDO JDBC Whatever
Internal state of system represented by

73
The Model portion of an MVC-based system can be often be divided into two major subsystems -- the internal state of the system and the actions that can be taken to change that state. In grammatical terms, we might think about state information as nouns (things) and actions as verbs (changes to the state of those things). Many applications represent the internal state of the system as a set of one or more JavaBeans. The bean properties represent the details of the system' state. Depending on your application's complexity, these beans may be self contained (and know how to persist their own state), or they may be facades that know how to retrieve the system's state from another component. This component may be a database, a search engine, an Entity Enterprise JavaBean, a LDAP server, or something else entirely. Many requirements documents used for building web applications focus on the View. However, you should ensure that the processing required for each submitted request is also clearly defined from the Model's perspective. In general, the developer of the Model components will be focusing on the creation of JavaBeans classes that support all of the functional requirements. The precise nature of the beans required by a particular application will vary widely depending on those requirements, but they can generally be classified into several categories discussed below.
03/01/2006
74
This picture shows where the model components fits. As the picture shows, actual model components can be in any form including JavaBeans, JDO, CORBA, EJB, JDBC or whatever that can be used to maintain some internal state.
03/01/2006
Model Components
?
JavaBeans and Scope

Page visible within a single JSP page, for the lifetime of the current request Request visible within a single JSP page, as well as to any page or servlet that is included in this page, or forwarded to by this page Session visible to all JSP pages and servlets that participate in a particular user session, across one or more requests Application - visible to all JSP pages and servlets that are part of a web application
75
Within a web-based application, JavaBeans can be stored in (and accessed from) a number of different collections of "attributes". Each collection has different rules for the lifetime of that collection, and the visibility of the beans stored there. Together, the rules defining lifetime and visibility are called the scope of those beans. The JavaServer Pages (JSP) Specification defines scope choices using the following terms (with the equivalent servlet API concept defined in parentheses): # page - Beans that are visible within a single JSP page, for the lifetime of the current request. (Local variables of the service method) # request - Beans that are visible within a single JSP page, as well as to any page or servlet that is included in this page, or forwarded to by this page. (Request attributes) # session - Beans that are visible to all JSP pages and servlets that participate in a particular user session, across one or more requests. (Session attributes) # application - Beans that are visible to all JSP pages and servlets that are part of a web application. (Servlet context attributes)
03/01/2006
Model Components
?
JSP pages and servlets in the same web application share the same sets of bean collections Example
Servlet code
? ?
MyCart mycart = new MyCart(...); request.setAttribute("cart", mycart); <jsp:useBean id="cart" scope="request" class="com.mycompany.MyApp.MyCart"/>
76
JSP page
? ?
It is important to remember that JSP pages and servlets in the same web application share the same sets of bean collections. For example, a bean stored as a request attribute in a servlet like this: MyCart mycart = new MyCart(...); request.setAttribute("cart", mycart); is immediately visible to a JSP page which this servlet forwards to, using a standard action tag like this: <jsp:useBean id="cart" scope="request" class="com.mycompany.MyApp.MyCart"/>
03/01/2006
Model Components in Struts Framework

?
ActionForm Bean (with a caveat)
Please note that many people don't regard ActionForm Bean as a Model component, instead it just represents input data entered by a user This is a conceptual term: Struts does not provide any programming API This is a conceptual term: Struts does not provide any programming API
77
SystemState Bean
BusinessLogic Bean
(read slide)
03/01/2006
Struts Model Components System State Bean & Business logic Bean
78
03/01/2006
System State Bean

? ?
Struts does not define formal class of this Defines the current state
Could be represented as a set of one or more JavaBeans classes, whose properties define the current state Contains a bean that represents the cart being maintained for each individual shopper Includes the set of items that the shopper has currently selected for purchase
79
Example: a shopping cart system:

The actual state of a system is normally represented as a set of one or more JavaBeans classes, whose properties define the current state. A shopping cart system, for example, will include a bean that represents the cart being maintained for each individual shopper, and will (among other things) include the set of items that the shopper has currently selected for purchase. Separately, the system will also include different beans for the user's profile information (including their credit card and ship-to addresses), as well as the catalog of available items and their current inventory levels.
03/01/2006
SystemState Bean
?
For small scale systems or for state information that need not be kept for a long period of time
a set of system state beans may contain all the knowledge that the system ever has System state beans may represent information that is stored permanently in some external database
?
Large scale application
CustomerBean object that corresponds to a particular row in the CUSTOMERS table

80
EJB might be used
For small scale systems, or for state information that need not be kept for a long period of time, a set of system state beans may contain all the knowledge that the system ever has of these particular details. Or, as is often the case, the system state beans will represent information that is stored permanently in some external database (such as a CustomerBean object that corresponds to a particular row in the CUSTOMERS table), and are created or removed from the server's memory as needed. Entity Enterprise JavaBeans are also used for this purpose in large scale applications.
03/01/2006
BuesinessLogic Bean
?
Struts does not define formal class of this

Can be an ordinary JavaBean Can be stateful or stateless EJB
Encapsulates functional logic of an application using method calls Action object should translate the HTTP request then call BusinessLogic bean
81
You should encapsulate the functional logic of your application as method calls on JavaBeans designed for this purpose. These methods may be part of the same classes used for the system state beans, or they may be in separate classes dedicated to performing the logic. In the latter case, you will usually need to pass the system state beans to be manipulated to these methods as arguments. Depending on the complexity and scope of your application, business logic beans might be ordinary JavaBeans that interact with system state beans passed as arguments, or ordinary JavaBeans that access a database using JDBC calls. For larger applications, these beans will often be stateful or stateless Enterprise JavaBeans (EJBs) instead.
03/01/2006
BuesinessLogic Bean
?
Ideally should be designed so that they do not know they are being executed in a web application environment

should not refer any Web application objects enhanced reusability
82
For maximum code re-use, business logic beans should be designed and implemented so that they do not know they are being executed in a web application environment. If you find yourself having to import a javax.servlet.* class in your bean, you are tying this business logic to the web application environment. Consider rearranging things so that your Action classes (part of the Controller role, as described below) translate all required information from the HTTP request being processed into property setter calls on your business logic beans, after which a call to an execute method can be made. Such a business logic class can be reused in environments other than the web application for which they were initially constructed.
03/01/2006
View Components (You provide them)

83
03/01/2006
84
This picture shows where the view components fit in the bug picture.
03/01/2006
View Components
?
? ? ?
JSP files which you write for your specific application Set of JSP custom tag libraries Resource files for internationalization Allows for fast creation of forms for an application Works in concert with the controller Servlet
85
Many applications rely on JavaServer Pages (JSP) technology to create the presentation layer (View). The Struts distribution includes a comprehensive JSP tag library that provides support for building internationalized applications, as well as for interacting with input forms.
03/01/2006
View
?
ActionForward object tells Servlet controller which JSP page is to be dispatched to JSP pages use ActionForm beans to get output Model data to display Struts contains a series of tag libraries

Facilitates communication between HTML designers and developers Facilitates dynamic Web content
86
03/01/2006
Forms and FormBean Interactions

?
If the user makes an error, the application should allow them to fix just what needs to be changed With just JSP, you have to do
<input type="text" name="username" value="<%= loginBean.getUsername() >"/>
With Struts, you can do

<html:text property="username"/>;
87
At one time or another, most web developers have built forms using the standard capabilities of HTML, such as the <input> tag. Users have come to expect interactive applications to have certain behaviors, and one of these expectations relates to error handling -- if the user makes an error, the application should allow them to fix just what needs to be changed -- without having to re-enter any of the rest of the information on the current page or form. Fulfilling this expectation is tedious and cumbersome when coding with standard HTML and JSP pages. For example, an input element for a username field might look like this (in JSP): <input type="text" name="username" value="<%= loginBean.getUsername() >"/> which is difficult to type correctly, confuses HTML developers who are not knowledgeable about programming concepts, and can cause problems with HTML editors. Instead, Struts provides a comprehensive facility for building forms, based on the Custom Tag Library facility of JSP 1.1. The case above would be rendered like this using Struts: <html:text property="username"/>; with no need to explicitly refer to the JavaBean from which the initial value is retrieved. That is handled automatically by the JSP tag, using facilities provided by the framework.
03/01/2006
Example: submit.jsp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 <%@ <%@ <%@ <%@ page language= " java " %> taglib uri= " /WEB-INF/struts-bean.tld " prefix= " bean " %> taglib uri= " /WEB-INF/struts-html.tld " prefix= " html" %> taglib uri= " /WEB-INF/struts-logic.tld " prefix= " logic" %> <html> <head><title>Submit example</title></head> <body> <h3>Example Submit Page</h3> <html:errors/> <html:form action= " submit.do " > Last Name: <html:text property= " lastName " /><br> Address: <html:textarea property= " address " /><br> Sex: <html:radio property= " sex " value= " M " />Male <html:radio property= " sex" value= " F " />Female<br> Married: <html:checkbox property= " married " /><br> Age: <html:select property= " age " > <html:option value= " a " >0-19</html:option> <html:option value= " b " >20-49</html:option> <html:option value= " c " >50-</html:option> </html:select><br> <html:submit/> </html:form> 88
This slide shows submit.jsp page which is the only JSP page used in the very simple application we built.
03/01/2006
Example: submit.jsp
1 2 3 4 5 6 7 8 9 10 11 12 13 <logic:present name=" lastName " scope= " request" > Hello <logic:equal name= " submitForm" property= " age " value= " a " > young </logic:equal> <logic:equal name= " submitForm" property= " age " value= " c " > old </logic:equal> <bean:write name= " lastName " scope= " request" /> </logic:present> </body> </html>
89
03/01/2006
web.xml
90
03/01/2006
Web App Deployment Descriptor (web.xml)

?
Struts application is a Web application

Follows the same rule Has to have web.xml deployment descriptor Configure ActionServlet instance and mapping Resource file as <init-param> servlet-config.xml file as <init-param> Define the Struts tag libraries
91
web.xml includes:

web.xml is stored in WEB-INF/web.xml
Since Struts application is a genuine Web application, it has to follow the same rule that any Web application has to follow. One of the rules is every Web application has to have a web.xml deployment descriptor. In aStruts application, web.xml contains servlet definition and mapping of ActionServlet. It also contains resource file and struts-config.xml definitions. Also it has definitions of struts tag libraries. Just like any other Web application, web.xml resides under WEB-INF directory either in packed form (*.war file) or unpacked form.
03/01/2006
Example: web.xml
1 <!DOCTYPE web-app 2 PUBLIC " -//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" 3 "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd" > 4 5 <web-app> 6 <display-name>Advanced J2EE Programming Class Sample App</display-name> 7 8  9 <servlet> 10 <servlet-name>action</servlet-name> 11 <servlet-class> 12 org.apache.struts.action.ActionServlet 13 </servlet-class> 14 <init-param> 15 <param-name>application</param-name> 16 <param-value>ApplicationResources</param-value> 17 </init-param> 18 <init-param> 19 <param-name>config</param-name> 20 <param-value>/WEB-INF/struts-config.xml</param-value> 21 </init-param> 22 </servlet>
92
03/01/2006
Example: web.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21  <servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping>  <taglib> <taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri> <taglib-location>/WEB-INF/struts-bean.tld</taglib-location> </taglib> <taglib> <taglib-uri>/WEB-INF/struts-html.tld</taglib-uri> <taglib-location>/WEB-INF/struts-html.tld</taglib-location> </taglib> <taglib> <taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri> <taglib-location>/WEB-INF/struts-logic.tld</taglib-location> </taglib> </web-app>
93
03/01/2006
Internationalization
94
A few years ago, application developers could count on having to support only residents of their own country, who are used to only one (or sometimes two) languages, and one way to represent numeric quantities like dates, numbers, and monetary values. However, the explosion of application development based on web technologies, as well as the deployment of such applications on the Internet and other broadly accessible networks, have rendered national boundaries invisible in many cases. This has translated (if you will pardon the pun) into a need for applications to support internationalization (often called "i18n" because 18 is the number of letters in between the "i" and the "n") and localization.
03/01/2006
Internationalization
?
Extends basic approach of java.util.ResourceBundle
org.apache.struts.util.MessageResources
? ?
Allows specification of dynamic locale key on a per user basis Limited to presentation, not input Configure resource bundles in web.xml file
95
Struts builds upon the standard classes available on the Java platform to build internationalized and localized applications. The key concepts to become familiar with are: * Locale - The fundamental Java class that supports internationalization is Locale. Each Locale represents a particular choice of country and language (plus an optional language variant), and also a set of formatting assumptions for things like numbers and dates. * ResourceBundle - The java.util.ResourceBundle class provides the fundamental tools for supporting messages in multiple languages. See the Javadocs for the ResourceBundle class, and the information on Internationalization in the documentation bundle for your JDK release, for more information. Please note that the i18n support in a framework like Struts is limited to the presentation of internationalized text and images to the user. Support for Locale specific input methods (used with languages such as Japanese, Chinese, and Korean) is left up to the client device, whichis usually a web browser.
03/01/2006
Internationalization: Developer responsibilities

? ?
Create resource file for a default language Create resource files for each language you want to support Define base name of the resource bundle in an initialization parameter In JSP page
Use <html:errors/> to display locale specific error messages
96
03/01/2006
Resource files
?
MyApplication.properties

Contains the messages in the default language for your server If your default language is English, you might have an entry like this:
?
prompt.hello=Hello
MyApplication_xx.properties
Contains the same messages in the language whose ISO language code is "xx"
?
prompt.hello=Bonjour
97
Assume that your source code is created in package com.mycompany.mypackage, so it is stored in a directory (relative to your source directory) named com/mycompany/mypackage. To create a resource bundle called com.mycompany.mypackage.MyApplication, you would create the following files in the com/mycompany/mypackage directory: * MyApplication.properties - Contains the messages in the default language for your server. If your default language is English, you might have an entry like this: prompt.hello=Hello * MyApplication_xx.properties - Contains the same messages in the language whose ISO language code is "xx" (See the ResourceBundle Javadoc page for a link to the current list). For a French version of the message shown above, you would have this entry: prompt.hello=Bonjour You can have resource bundle files for as many languages as you need.
03/01/2006
Example: ApplicationResource.properties
1 2 3 4 5 6 7 errors.header=<h4>Validation Error(s)</h4><ul> errors.footer=</ul><hr> error.lastName=<li>Enter your last name error.address=<li>Enter your address error.sex=<li>Enter your sex error.age=<li>Enter your age
98
03/01/2006
Example: web.xml
1
2 3 4 5 6 7 8 9 10 11 12 13
<servlet> <servlet-name>action</servlet-name> <servlet-class> org.apache.struts.action.ActionServlet </servlet-class> <init-param> <param-name>application</param-name> <param-value> com.mycompany.mypackage.MyApplication </param-value> </init-param>  </servlet>
99
When you configure the controller servlet in the web application deployment descriptor, one of the things you will need to define in an initialization parameter is the base name of the resource bundle for the application. In the case described above, it would be com.mycompany.mypackage.MyApplication. <servlet> <servlet-name>action</servlet-name> <servlet-class> org.apache.struts.action.ActionServlet </servlet-class> <init-param> <param-name>application</param-name> <param-value> com.mycompany.mypackage.MyResources </param-value> </init-param>  </servlet>
03/01/2006
(Input) Validation
100
Validation is sometimes called input validation or form validation.
03/01/2006
Validation: Developer responsibilities (Struts 1.0)

?
Indicate you want input validation as attributes of <action> element under <action-mapping> in servlet-config.xml file
validate=true
Specify the JSP page that needs to be displayed when validation fails
input=/errorpage.jsp
Override validate() method within ActionForm class
optional
101
(read slide)
03/01/2006
validate() method
?
Called by the controller servlet

after the bean properties have been populated but before the corresponding action class's execute () method is invoked default method returns null
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request);
Optional
Syntax
102
In addition to the form and bean interactions described above, Struts offers an additional facility to validate the input fields it has received. To utilize this feature, override the following method in your ActionForm class: validate(ActionMapping mapping, HttpServletRequest request); The validate method is called by the controller servlet after the bean properties have been populated, but before the corresponding action class's execute method is invoked. The validate method is called by the controller servlet after the bean properties have been populated, but before the corresponding action class's execute method is invoked.
03/01/2006
Example: validate() method

?
In Login application

Make sure both username and password are entered Make sure password is more than 6 chracters
103
03/01/2006
validate() method
?
After performing validation

if no validation error, return null If validation error, return ActionErrors ? Each ActionError contains error message key into the application's MessageResources bundle ? The controller servlet stores ActionErrors array as a request attribute suitable for use by the <html:errors> tag ? The controller then forwards control back to the input form (identified by the input property for this ActionMapping)
104
The validate method has the following options: * Perform the appropriate validations and find no problems -- Return either null or a zero-length ActionErrors instance, and the controller servlet will proceed to call the perform method of the appropriate Action class. * Perform the appropriate validations and find problems -- Return an ActionErrors instance containing ActionError's, which are classes that contain the error message keys (into the application's MessageResources bundle) that should be displayed. The controller servlet will store this array as a request attribute suitable for use by the <html:errors> tag, and will forward control back to the input form (identified by the input property for this ActionMapping).
03/01/2006
ActionError Class
?
Mechanism used to return errors during input validation Encapsulate errors
message key used for text lookup from resource file
? ?
Supports parametric replacement ActionErrors is a collection of ActionError
105
03/01/2006
struts-config.xml: Validation
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17  <action-mappings> <action path="/submit" type="hansen.playground.SubmitAction" name="submitForm" input="/submit.jsp" scope="request" validate="true"> <forward name="success" path="/submit.jsp"/> <forward name="failure" path="/submit.jsp"/> </action> </action-mappings> </struts-config>
106
This shows the struts-config.xml settings for validation. The input attribute is set to /submit.jsp, which means when input validation error occurs, we display the same submit.jsp page. Again, you can change the value of this attribute to be another JSP page.
03/01/2006
ActionForm
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 public final class SubmitForm extends ActionForm { ... public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) { ... // Check for mandatory data ActionErrors errors = new ActionErrors(); if (lastName == null || lastName.equals( " " )) { errors.add( " Last Name " , new ActionError( " error.lastName " )); } if (address == null || address.equals( " " )) { errors.add( " Address " , new ActionError( " error.address " )); } if (sex == null || sex.equals( " " )) { errors.add( " Sex " , new ActionError( " error.sex" )); } if (age == null || age.equals( " " )) { errors.add( " Age " , new ActionError( " error.age " )); } return errors; } .. } 107
This is the example validate() code in submitHansen sample code. Here the validation logic is basically checking if the value has been entered or not. Please note that for each input validation error, ActionError object is created and then added to ActionErrors array.
03/01/2006
Example: submit.jsp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 <%@ page language= " java " %> <%@ taglib uri= " /WEB-INF/struts-bean.tld " prefix=" bean " %> <%@ taglib uri= " /WEB-INF/struts-html.tld " prefix= " html " %> <%@ taglib uri= " /WEB-INF/struts-logic.tld " prefix= " logic" %> <html> <head><title>Submit example</title></head> <body> <h3>Example Submit Page</h3> <html:errors/> <html:form action= " submit.do " > Last Name: <html:text property=lastName/><br> " " Address: <html:textarea property= " address " /><br> Sex: <html:radio property=" sex" value= " M " />Male <html:radio property=" sex " value=" F" />Female<br> Married: <html:checkbox property=" married " /><br> Age: <html:select property="a g e "> <html:option value= " a" >0-19</html:option> <html:option value= " b " >20-49</html:option> <html:option value= " c " >50-</html:option> </html:select><br> <html:submit/> </html:form> 108
This is submit.jsp page in which the error information that is collected in the form of ActionErrors array object gets displayed via <html:errors/> tag.
03/01/2006
Validator Framework in Struts 1.1

?
Validation logic can be specified in strutsconfig.xml configuration file
Instead of writing Java code - validate() method
We will learn about it in Advanced Struts session
109
(read slide)
03/01/2006
Error Handling
110
03/01/2006
Input validation vs. Business logic Validation

?
Perform simple, prima facia validations using the ActionForm validate() method
Even this is optional
Handle the "business logic" validation in the Action class
111
As mentioned earlier, this feature is entirely optional. The default implementation of the validate method returns null, and the controller servlet will assume that any required validation is done by the action class. One common approach is to perform simple, prima facia validations using the ActionForm validate method, and then handle the "business logic" validation from the Action. The Struts Validator , may be used to easily validate ActionForms.
03/01/2006
Application Errors in Action Class

?
? ?
Capture errors from System State bean or Business Logic bean Create ActionErrors object and return ActionServlet can take action if a certain exception is thrown

Can be global or Action-based Can either be a simple forward, or passed to a custom error handler class Through defaut ExceptionHandler
112
03/01/2006
CustomExceptionHandler (1.1)
?
Define a custom ExceptionHandler to execute when an Action's execute() method throws an Exception

Subclass org.apache.struts.action.ExceptionHandler Your execute() method should process the Exception and return an ActionForward object to tell Struts where to forward to next Define one for java.lang.Exception for debugging purpose
113
Example
The default Struts exception handler class creates an ActionError object and stores it in the appropriate scope object. This allows the JSP pages to use the errors to inform the user of a problem. If this behavior does not fulfill your requirements, you are free to plug in one of your own ExceptionHandler classes. You can define an custom ExceptionHandler to execute when an Action's execute method throws an Exception. First, you need to subclass org.apache.struts.action.ExceptionHandler and override the execute method. Your execute method should process the Exception and return an ActionForward object to tell Struts where to forward to next. You can override global exception handlers by defining a handler inside an action definition. A common use of ExceptionHandlers is to configure one for java.lang.Exception so it's called for any exception and log the exception to some data store.
03/01/2006
Custom ExceptionHandler (1.1)

?
Configure your custom exception handler in struts-config.xml

<global-exceptions> <exception key="some.key" type="java.io.IOException" handler="com.yourcorp.ExceptionHandler"/> </global-exceptions>
com.yourcorp.ExceptionHandler.execute() will be called when any IOException is thrown by an Action

114
Once you have created your specialized ExceptionHandler class, you will need to inform the Struts framework to use your version instead of the default Struts exception handler. To do this, you will just need to declare your class in the Struts configuration file. Then you configure your handler in struts-config.xml like this: <global-exceptions> <exception key="some.key" type="java.io.IOException" handler="com.yourcorp.ExceptionHandler"/> </global-exceptions> This configuration element says that com.yourcorp.ExceptionHandler.execute will be called when any IOException is thrown by an Action. The key is a key into your message resources properties file that can be used to retrieve an error message.
03/01/2006
CustomExceptionHandler (1.1)
?
Can be either global or per action

<action ...> <exception key="some.key" type="java.io.IOException" handler="com.yourcorp.ExceptionHandler"/> </action>
115
03/01/2006
Example: Throwing an Exception

1 package hansen.playground; 2 import javax.servlet.http.*; 3 import org.apache.struts.action.*; 4 public final class SubmitAction extends Action { 5 public ActionForward execute(ActionMapping mapping, 6 ActionForm form, 7 HttpServletRequest request, 8 HttpServletResponse response) { 9 10 SubmitForm f = (SubmitForm) form; // get the form bean 11 // and take the last name value 12 String lastName = f.getLastName(); 13 if (lastName.startsWith(Passion)){ 14 // Translate the name to upper case 15 //and save it in the request object 16 request.setAttribute("lastName", lastName.toUpperCase()); 17 // Forward control to the specified success target 18 return (mapping.findForward("success")); 19 } 20 else{ 21 throw new WrongLastNameExcetion(lastName); 22 } 23 } 24 }
116
03/01/2006
Custom ExceptionHandler (1.1)

?
Different ExceptionHandler for different error
<global-exceptions> <exception handler="com.cavaness.storefront.CustomizedExceptionHandler" key="global.error.message" path="/error.jsp" scope="request" type="java.lang.Exception"/> <exception handler="com.cavaness.storefront.SecurityExceptionHandler" key="security.error.message" path="/login.jsp" scope="request" type="com.cavaness.storefront.SecurityException"/> </global-exceptions>
117
You can create multiple exception handlers, each one worrying about different exceptions. In this case, when an exception is thrown, the framework will attempt to find an ExceptionHandler configured for the exact match. If there's no exact match, the framework will proceed up the superclass chain of the exception until a match is found. With this approach, you can have a hierarchical relationship of handlers, and all of it declarative.
03/01/2006
View Selection
118
03/01/2006
View Selection: Developer responsibilities

?
In struts-config file,
Indicate to be forwarded JSP page (or Tiles definition, another action, Velocity template) for each outcome via <forward> child element of <action> element or <global-forwards> Return ActionForward object which is associated with a particular logical outcome
In execute() method of Action class,
119
03/01/2006
struts-config.xml: ActionMapping
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17  <action-mappings> <action path="/submit" type="hansen.playground.SubmitAction" name="submitForm" input="/submit.jsp" scope="request" validate="true"> <forward name="success" path="/submit.jsp"/> <forward name="failure" path="/submit.jsp"/> </action> </action-mappings> </struts-config>
120
03/01/2006
Example: Action Class

1 package hansen.playground; 2 3 import javax.servlet.http.*; 4 import org.apache.struts.action.*; 5 6 public final class SubmitAction extends Action { 7 8 public ActionForward execute(ActionMapping mapping, 9 ActionForm form, 10 HttpServletRequest request, 11 HttpServletResponse response) { 12 13 SubmitForm f = (SubmitForm) form; // get the form bean 14 // and take the last name value 15 String lastName = f.getLastName(); 16 // Translate the name to upper case 17 //and save it in the request object 18 request.setAttribute("lastName", lastName.toUpperCase()); 19 20 // Forward control to the specified success target 21 return (mapping.findForward("success")); 22 } 23 } 24
121
03/01/2006
Passion!
122

21-StrutsBasics 122

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

21-StrutsBasics 122

Uploaded by

Copyright:

Available Formats

03/01/2006

Disclaimer & Acknowledgments

What is and Why Struts? Struts architecture

Controller: Focus of this presentation Model View

Includes JSP custom tag libraries

Struts allows Web Application Developers to ...

Struts Architecture (Quick Overview)

te tia tan Ins

(Model) Java Bean

How Struts Works

Struts: MVC-based Architecture

Struts: MVC-based Architecture

3 Major Components in Struts

Struts is focused on Controller

Struts: MVC-based Architecture

Configuration file contains action mappings

Mapping must specify

So let's talk about Controller piece of the Struts.

What does Controller do?

reads configuration file to determine the flow control

source: Chuck Cavaness

Controller in Struts Framework

Struts framework provides a built-in base servlet

org.apache.struts.action.ActionServlet Servlet mapping has to be configured in web.xml

Struts related configuration is done through struts-config.xml

override execute() method (perform() method in Struts 1.0) struts-config.xml

Write the action mapping configuration file

Controller Components in Struts Framework

ActionServlet (Provided by Struts) RequestProcessor (Struts 1.1)(Provided by Struts)

Action (Provided by developer)

Action Mapping (Specified by developer)

What Does ActionServlet Do?

Performs the role of Controller

Delegates most of this grunt work to Action classes

What Does ActionServlet Do? (Continued)

Is responsible for initialization and clean-up of resources

Flow control by Controller

Struts Flow (Struts 1.0)

What Does RequestProcessor Do?

What Does RequestProcessor Do?

What Does RequestProcessor Do?

What Does RequestProcessor Do?

What Does RequestProcessor Do?

What Does RequestProcessor Do?

Action Mapping (You provide it)

Action Mapping in Struts Config File

Struts Config File (struts-config.xml)

struts-config.xml contains three important elements used to describe actions:

Use an <action> element for each action defined

<global-forwards> contains your global forward definitions

Struts Config File (struts-config.xml)

struts-config.xml: <form-beans> from struts-submit application

Struts Config File (struts-config.xml)

Struts Config File (struts-config.xml)

Each <action> element requires the following attributes to be defined:

struts-config.xml: <action-mappings> from struts-submit application

struts-config.xml: <action-mappings> from struts-example application

Action Mapping Config File

ActionForm (You provide it unless you use DynaActionForm)

ActionForm Bean (Form bean)

ActionForm Bean & Controller

How to write ActionForm Bean