Struts PPT

transcript

Struts an MVC framework

Prasad Chaturvedula

Introduction

Components of a struts app

Impact on development lifecycle

Best Practices

Struts Framework provides the Controller portion of the application

Receives requests from the client, decide what business logic function to perform, and delegate responsibility for producing the next phase of the user interface to an appropriate View component

Background

Components of a struts app The Action Servlet

The config file

ActionMapping

The Action Form

The Action Class

Action Errors and Validation framework

Data subsets

Action Servlet A normal servlet with some processing methods

thrown in to load config files and resource files

Reads config file and converts XML tagged information into copncrete Java objects using Digester

Delegates handling of a request to the Request Processor

Servlet Initialization parameters

configFile, configFactory, appResources

Road Ahead

<servlet> <servlet-name>action</servlet-name> <servlet-class>org.apache.struts.action.ActionServlet</servlet-class> <init-param> <param-name>config</param-name> <param-value>/WEB-INF/struts-config.xml</param-value> </init-param></servlet>

<servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.do</url-pattern></servlet-mapping>

Road Ahead

This servlet is responsible for handing all the request for the Struts Framework, user can map the specific pattern of request to the ActionServlet. <servlet-mapping> tag in the web.xml file specifies the url pattern to be handled by the servlet

The above mapping maps all the requests ending with .do to the ActionServlet. ActionServlet uses the configuration defined in struts-config.xml file to decide the destination of the request. Action Mapping Definitions is used to map any action

Why bother?

RequestProcessor Identify, from the incoming request URI, the substring

that will be used to select an action procedure.

Use this substring to map to the Java class name of the corresponding action class

If this is the first request for a particular <code>Action</code> class, instantiate an instance of that class and cache it for future use.

Only 1 instance of the Action class for all requests

Work Flow

RequestProcessor contd Optionally populate the properties of an ActionForm bean

associated with this mapping.

Call the execute method of this Action class, passing on a reference to the mapping that was used, the relevant form-bean (if any), and the request and the response that were passed to the controller by the servlet container (thereby providing access to any specialized properties of the mapping itself as well as to the ServletContext).

Add-Ons

RequestProcessor Internals Process method called by ActionServlet Process calls a series of processXXX methods which perform

pre-defined preprocessing processActionCreate processActionForm processPopulate processValidate processActionPerform processException processForward processForwardConfig .

Road Ahead

The struts-config.xml file

Used to define and initialize resources like

ActionForms to collect input from users

ActionMappings to direct input to server-side Actions

ActionForwards to select output pages

DataSources for DB connections

Global Forwards

Global Exceptions

Road Ahead

ActionMapping

name="AddressForm" scope="request" validate="true" input="/pages/Address.jsp">

</action>

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

Contains where the request is coming from (sourcePage)

the name fo the ActionForm containing the user input

The Action class which should handle this request

The destination resource(s)

ActionForm

Encapsulates User input

Makes it easy to store and validate the data for an application's input forms

The framework sets the ActionForm's properties from the request parameters and sends the validated form to the

appropriate Action's execute method

Forget code like Integer.parseInt(request.getParameter

(“something”));

Action Class Has 2 methods-

public ActionForward execute(ActionMapping mapping, ActionForm form,

ServletRequest request, ServletResponse response)

throws Exception;

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse

response) throws Exception

Action Class Typical functionality contd..

Validate the current state of the user's session (for example, checking that the user has successfully logged on)

Validat form data, 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

Action class Typical functionality contd…

Perform the processing required to deal with this request

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)

Return an appropriate ActionForward object that identifies the presentation page to be used to generate this response, based on the newly updated beans.

The Struts Framework – Architecture

Exception Handling

Define global exception handlers to execute when an Action class throws an Exception

Used to group generic exceptions in an application

Framewor takes care of forwarding to appropriate JSP on occurrence

Exception Handling contd

<global-exceptions>

<exception key="some.key"

type="java.io.IOException"

handler="com.yourcorp.

ExceptionHandler"/>

</global-exceptions>

Global Forwards

Forwards are instances of the ActionForward class returned from an Action's execute method

Map logical names to specific resources (typically JSPs), allowing you to change the resource without changing references to it throughout your application.

Typical usage- Forwarding to login pages

Global Forwards contd

<global-forwards type="org.apache.struts.action.ActionFor

ward">

<forward name="logon" path="/logon.jsp"

redirect="false" />

</global-forwards>

Struts validation framework

A single definition of validation rules for an application

Validation rules are loosely coupled to the application

Supports Internationalization.

Supports regular expressions

Struts validator framework contd…

validator.-rules.xml- defines the rule to be applied

Example- “required”

<validator name="required" classname="org.apache.struts.util.StrutsValidator"

method="validateRequired"

methodparams=“” msg="errors.required"/>

Struts validator framework contd…validaton.xml- tie the rule to the ActionForm<form-validation>

<field property="firstName"

depends="required">

</field>

Why all this?

Clear separation between layers resulting In clear separation of roles and clear interface between programmers

View writer responsible for JSPs and ActionForms

Model writer provides his objects as DAOs or EJBs

Application writer concentrates on “strutting” it all together with Action Classes and the config file

Resulting in faster development

With Struts 1.2 we have the ability to maintain multiple config files to enable to divide a large aplication into modules

This further facilitates easy co-ordination between programmers in a large application

Easy to maintain- how?

Most varying parts of an application ar defined at 1 central place- The config file

The names of JSPs in ActionForwards

The exception handlers

The global forwards

The Action calss itself changes

Facility of using wildcards in mappings

Easy to maintain- Internationalization

All the Message resources of an app defined in Application.resources

For a new language add a locale specific Application.resources and use it.

Best Practices

Designing Action Classes Use Business Delegate Objects or DAOs to access

databases Don’t validate Business rules in the Action classes-

A mail acount registration example Key idea- Separation between Data and

Presentation of data Action Classes should only do data type validation

but should leave Business rule validations to the Business tier

Use DispatchAction for CRUD functions on same set of data

Use Javascript to modify a variable in the form to specify operation(C or R or U or D)<SCRIPT>function set(target) {document.forms[0].methodToCall.value=target;}</SCRIPT><html:submit onclick="set(‘insert');">SAVE

</html:submit><html:submit onclick="set(‘update');">

SAVE AS NEW</html:submitl>

Modify the Action Mapping to indicate dispatch variable

Add “methodToCall” methods in the Action class public ActionForward insert(

ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { ...

public ActionForward update( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { ...

Use LookupDispatchAction for script free dispatch In our JSP, we can refer to the buttons in the usual

way <html:form action="/test">

<html:submit><bean:message key="button.add"/></html:submit><html:submit><bean:message key="button.delete"/></html:submit></html:form>

LookupDispatchAction would have a method

protected Map getKeyMethodMap(ActionMapping mapping, ActionForm form, HttpServletRequest request) { Map map = new HashMap(); map.put("button.add", "add"); map.put("button.delete", "delete"); return map;}

Screens with dynamic fields

Use String[] getProperty() and setProperty(String[]) methods

Use DynaActionForm

Safeguarding JSPs <web-app>

<security-constraint> <web-resource-collection> <web-resource-name>no_access</web-resource-name> <url-pattern>*.jsp</url-pattern> </web-resource-collection> <auth-constraint/> </security-constraint> </web-app>

ActionForms- Coarse grained or fine grained

Fine-grained Too specific

Many in number

Ties records in database to view side

Coarse-grained Immune to changes in table structure

Better manageability

Use ResultObjects to return data to View

Result object is simply a transfer object equipped with methods designed to give the presentation layer a helping hand

Usually just a wrapper around some collection class int getSize() String getDescription() – Iterator getIterator()

Error Categorization

Register the errors under the appropriate category errors.add("fatal", new ActionError("....")); or

errors.add("error", new ActionError("...."));

Identify these messages and show them consistently

<logic:messagePresent property="error"> <html:messages property="error" id="errMsg" > <bean:write name="errMsg"/></html:messages></logic:messagePresent >

Struts PPT

Documents