TWINCLING

freedom of innovation

Jakarta Struts
An Apache Software Foundation Project

25th February, 2006

Hyderabad,
AP India
 Servlets
• Replaces CGI
↑ Single heavy weight process – multiple
lightweight threads
↑ Availability of entire Java API
↓ Hard-coding HTML
↓ Internationalization overhead
 JavaServer Pages
• Combination of static HTML, XML like
tags and scriptlets
• Compiled
• Support for scripting and access to Java
API
• Extended through use of custom tags
JSP Model 1 Architecture
JSP Model 2 Architecture
 Overview
• Model-View-Controller Design Pattern
• Model Components
• View Components
• Controller Components
• Tag Libraries
• STRUTS Configuration File
• Web Application Descriptor File
• Application Resources File
• Resources
 Model-View-Controller
Design Pattern
• Central controller mediates application
flow
• Controller delegates to appropriate
handler
• Handlers are tied to model components
• Model encapsulates business logic
• Control forwarded back through the
Controller to the appropriate View
MVC Design Pattern
 MVC Design Pattern

• 3 Major Components in STRUTS

– Servlet controller (Controller)
– Java Server Pages (View)
– Application Business Logic (Model)
• Controller bundles and routes HTTP
request to other objects in framework
• Controller parses configuration file
 MVC Design Pattern

• Configuration file contains action

mappings (determines navigation)
• Controller uses mappings to turn HTTP
requests into application actions
• Mapping must specify
– A request path
– Object type to act upon the request
 Model Components
• Model divided into concepts
– Internal state of the system
– Actions that can change that state
• Internal state of system represented by
– JavaBeans
– Enterprise JavaBeans
 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
 Model Components

• ActionForm Beans
– Extends the ActionForm class
– Create one for each input form in the application
– If defined in the ActionMapping configuration file,
the Controller Servlet will perform the following:
• Check session for instance of bean of appropriate class
• If no session bean exists, one is created automatically
• For every request parameter whose name corresponds
to the name of a property in the bean, the corresponding
setter method will be called
• The updated ActionForm bean will be passed to the
Action Class perform() method when it is called, making
these values immediately available
 Model Components

• When coding ActionForm beans consider:

– 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
 Model Components

• Continued…
– 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
– Place a bean instance on your form, and use nested
property references. For example, you have a "customer"
bean on your Action Form, and then refer to the property
"customer.name" in your JSP view. This would correspond
to the methods customer.getName() and
customer.setName(string Name) on your customer bean
 Model Components

• Business Logic Beans

– Should encapsulate the functional logic of your
application as method calls on JavaBeans
designed for this purpose
– 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
– For small to medium sized applications, 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
 Model Components

• Accessing Relational Databases

– Struts can define the datasources for an
application from within its standard
configuration file
– A simple JDBC connection pool is also
provided
 View Components
• Internationalized Messages
– Struts builds upon Java platform to provide assistance for
building internationalized and localized applications
• Locale - fundamental Java class that supports
internationalization
• ResourceBundle - supports messages in multiple languages
• PropertyResourceBundle - standard implementation of
ResourceBundle that allows you to define resources using the
same "name=value" syntax used to initialize properties files
• MessageFormat - allows you to replace portions of a message
string with arguments specified at run time
• MessageResources - lets you treat a set of resource bundles
like a database, and allows you to request a particular message
string for a particular Locale
 View Components

• ApplicationResources.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
• ApplicationResources_xx.properties
– Contains the same messages in the
language whose ISO language code is "xx
• Forms and FormBean interactions
– HTML Forms and their limitations
– Errors not easily handled
<%@ page language="java" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<html:html>
<head> <title> <bean:message key="logon.title"/> </title>
<body bgcolor="white">
<html:errors/>
<html:form action=“/logonpath.do">
<table border="0" width="100%">
<tr> <th align="right"> <html:message key="prompt.username"/>
</th>
<td align="left"> <html:text property="username" size="16"/>
</td> </tr>
<tr> <td align="right"> <html:submit> <bean:message
key="button.submit"/> </html:submit> </td>
 View Components

• Building Forms with Struts

– The taglib directive tells the JSP page compiler
where to find the tag library descriptor for the
Struts tag library
– message tag is used to look up internationalized
message strings from a MessageResources
object containing all the resources for this
application
– The errors tag displays any error messages that
have been stored by a business logic component,
or nothing if no errors have been stored
 View Components

• Building Forms with Struts – continued

– The form tag renders an HTML <form> element, based on
the specified attributes
– The form tag also associates all of the fields within this form
with a request scoped FormBean that is stored under the
key FormName
– The form bean can also be specified in the Struts
configuration file, in which case the Name and Type can be
omitted here
– The text tag renders an HTML <input> element of type "text“
– The submit and reset tags generate the corresponding
buttons at the bottom of the form
• Input field types supported
– checkboxes
– hidden fields
– password input fields
– radio buttons
– reset buttons
– select lists
– options
– submit buttons
– text input fields
– textareas
• Useful Presentation Tags
– [html] link generates a HTML <a> element as an anchor
definition or a hyperlink to the specified URL, and
automatically applies URL encoding to maintain session
state in the absence of cookie support
– [html] img generates a HTML <img> element with the ability
to dynamically modify the URLs specified by the "src" and
"lowsrc" attributes in the same manner that <html:link> can
– [bean] parameter retrieves the value of the specified request
parameter, and defines the result as a page scope attribute
of type String or String
• Automatic Form Validation
– Struts offers an additional facility to
validate the input fields it has received
– To utilize this feature, override the
validate() method in your ActionForm class
– The validate() method is called by the
controller servlet after the bean properties
have been populated, but before the
corresponding action class's perform()
method is invoked
• Page Composition with Includes
– The development of the various segments
of a site is easier if you can divide up the
work, and assign different developers to
the different segments
– Use the include capability of JavaServer
Pages technology to combine the results
into a single result page, or use the include
tag provided with Struts
• Page Composition with Includes – continued
– There are three types of include available,
depending on when you want the combination of
output to occur:
• An <%@ include file="xxxxx" %> directive can include a
file that contains java code or jsp tags
• The include action (<jsp:include page="xxxxx"
flush="true" />) is processed at request time, and is
handled transparently by the server
• The bean:include tag takes either an argument "forward"
representing a logical name mapped to the jsp to include,
or the "id" argument, which represents a page context
String variable to print out to the jsp page
 Controller Components
• Struts includes a Servlet that
implements the primary function of
mapping a request URI to an Action
class (ActionServlet)
• Your primary responsibilities are:
– Write an Action class (that is, an extension of the
Action class) for each logical request that may be
received
– Write the action mapping configuration file (in
XML) that is used to configure the controller
servlet (struts-config.xml)
– Update the web application deployment descriptor
file (in XML) for your application to include the
necessary Struts components
– Add the appropriate Struts components to your
application
• Action Classes:
– The Action class defines a perform method
that you override
public ActionForward perform(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException;
• The goal of an Action class is to
process this request, and then to return
an ActionForward object that identifies
the JSP page (if any) to which control
should be forwarded to generate the
corresponding response
• A typical Action class will implement the
following logic in its perform() method
– Validate the current state of the user's session
– If validation has not yet occurred, validate the form
bean properties as necessary
– 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
– Return an appropriate ActionForward object that
identifies the JSP page to be used to generate this
response, based on the newly updated beans
• Design issues to remember when coding
Action classes include the following
– The controller Servlet creates only one instance of
your Action class, and uses it for all requests.
Thus, you need to code your Action class so that it
operates correctly in a multi-threaded
environment, just as you must code a Servlet's
service() method safely
– The most important principle that aids in thread-
safe coding is to use only local variables, not
instance variables, in your Action class
• Design issues to remember when coding
Action classes include the following –
continued
– The beans that represent the Model of your
system may throw exceptions due to problems
accessing databases or other resources. You
should trap all such exceptions in the logic of your
perform() method, and log them to the application
logfile
– As a general rule, allocating scarce resources and
keeping them across requests from the same user
(in the user's session) can cause scalability
problems
• The ActionMapping Implementation
• type - Fully qualified Java class name of the Action
implementation class used by this mapping.
• name - The name of the form bean defined in the config
file that this action will use
• path - The request URI path that is matched to select
this mapping. See below for examples of how matching
works.
• unknown - Set to true if this action should be configured
as the default for this application, to handle all requests
not handled by another action. Only one action can be
defined as a default within a single application.
• validate - Set to true if the validate() method of the action
associated with this mapping should be called.
• The Actions Mapping Configuration File
– The developer's responsibility is to create
an XML file named struts-config.xml, and
place it in the WEB-INF directory of your
application
– The outermost XML element must be
<struts-config>
– Inside of the <struts-config> element, there
two important elements that you use to
describe your actions:
• <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 or session level
attribute that this form bean will be stored as
– type: The fully-qualified Java classname of your form
bean
– <action-mappings>
This section contains your action definitions. You
use an <action> element for each of your actions
you would like to define. Each action element has
requires the following attributes to be defined:
• 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
– One more section of good use is the <data-sources>
section, which specifies data sources that your application
can use.This is how you would specify a basic data source
for your application inside of struts-config.xml:
<struts-config>
<data-sources>
<data-source autoCommit="false"
description="Example Data Source Description"
driverClass="org.postgresql.Driver" maxCount="4"
minCount="2" password="mypassword"
url="jdbc:postgresql://localhost/mydatabase"
user="myusername"/>
</data-sources>
</struts-config>
• The Web Application Deployment
Descriptor
– The final step in setting up the application
is to configure the application deployment
descriptor (stored in file WEB-INF/web.xml)
to include all the Struts components that
are required
 Tag Libraries
• HTML Tags
• Bean Tags
• Logic Tags
• Template Tags
• Custom Tags
The tags in the Struts HTML library form a bridge
between a JSP view and the other components
of a Web application. Since a dynamic Web
application often depends on gathering data from
a user, input forms play an important role in the
Struts framework. Consequently, the majority of
the HTML tags involve HTML forms. Other
important issues addressed by the Struts-HTML
tags are messages, error messages, hyperlinking
and internationalization.
 HTML Tags
• HTML "form" tags • HTML "form" tags
– button – select lists with
– cancel embedded
– checkboxes – option
– file – options
– hidden – submit buttons
– image – text input fields
– multibox – textareas
– password input fields
– radio buttons
– reset buttons
 HTML Tags – Typical HTML Form

<HTML>
<BODY>
<FORM>
<TABLE WIDTH="100%">
<TR><TD>First Name</TD>
<TD><INPUT TYPE="TEXT" NAME="Name" SIZE="40" MAXLENGTH="40"></TD></TR>
<TR><TD>Street Address</TD>
<TD><INPUT TYPE="TEXT" NAME="Address" SIZE="40" MAXLENGTH="40"></TD></TR>
<TR><TD>City</TD>
<TD><INPUT TYPE="TEXT" NAME="City" SIZE="20" MAXLENGTH="20"></TD></TR>
<TR><TD>State</TD>
<TD><INPUT TYPE="TEXT" NAME="State" SIZE="2" MAXLENGTH="2"></TD></TR>
<TR><TD>Postal Code</TD>
<TD><INPUT TYPE="TEXT" NAME="ZipCode" SIZE="9" MAXLENGTH="9"></TD></TR>
<TR><TD ALIGN=CENTER><INPUT TYPE="SUBMIT" NAME="Submit" VALUE="Save"></TD>
<TD><INPUT TYPE="RESET" NAME="Reset" VALUE="Cancel"></TD></TR>
</TABLE>
</FORM>
</BODY>
</HTML>
 HTML Tags – Typical Struts Form

<HTML:HTML>
<BODY>
<HTML:FORM Action="/CustomerForm" focus=“name” >
<TABLE WIDTH="100%">
<TR><TD><bean:message key="customer.name"/></TD>
<TD><HTML:TEXT property="name" size="40" maxlength="40" /></TD></TR>
<TR><TD><bean:message key="customer.address"/></TD>
<TD><HTML:TEXT property="address" size ="40" maxlength ="40" /></TD></TR>
<TR><TD><bean:message key="customer.city"/></TD>
<TD><HTML:TEXT property="city" size ="20" maxlength ="20" /></TD></TR>
<TR><TD><bean:message key="customer.state"/></TD>
<TD><HTML:TEXT property="state" size ="2" maxlength ="2" /></TD></TR>
<TR><TD><bean:message key="customer.zip"/></TD>
<TD><HTML:TEXT property="zip" size ="9" maxlength ="9" /></TD></TR>
<TR><TD ALIGN=CENTER><html:submit property="action" value ="Save"/></TD>
<TD><html:reset property="action" value ="Reset"/></TD></TR>
</TABLE>
</HTML:FORM>
</BODY>
</HTML:HTML>
 Bean Tags
• The "struts-bean" tag library provides substantial enhancements
to the basic capability provided by <jsp:useBean>, as discussed
in the following sections:
– Bean Properties - Extended syntax to refer to JavaBean properties
with simple names (same as the standard JSP tags
<jsp:getProperty> and <jsp:setProperty>), nested names (a
property named address.city returns the value retrieved by the Java
expression getAddress().getCity()), and indexed names (a property
named address[3] retrieves the fourth address from the indexed
"address" property of a bean).
– Bean Creation - New JSP beans, in any scope, can be created
from a variety of objects and APIs associated with the current
request, or with the servlet container in which this page is running.
– Bean Output - Supports the rendering of textual output from a
bean (or bean property), which will be included in the response
being created by your JSP page.
Tag Name Description

cookie Define a scripting variable based on the value(s) of the specified request cookie.

define Define a scripting variable based on the value(s) of the specified bean property.

header Define a scripting variable based on the value(s) of the specified request header.

include Load the response from a dynamic application request and make it available as a bean.

message Render an internationalized message string to the response.

page Expose a specified item from the page context as a bean.

parameter Define a scripting variable based on the value(s) of the specified request parameter.

resource Load a web application resource and make it available as a bean.

size Define a bean containing the number of elements in a Collection or Map.

struts Expose a named Struts internal configuration object as a bean.

write Render the value of the specified bean property to the current JspWriter.
 Bean Tag Example

<table border="2">
<tr>
<th align="left"><bean:message key=“imagebroker.lob”/></th>
<th align="left"><bean:message key=“imagebroker.unitnbr”/></th>
<th align="left"><bean:message key=“imagebroker.onbase_dns”/></th>
</tr>
<logic:iterate id="image" property="collection"
name="ImageLocationListForm">
<tr>
<td><a href="ImageLocationListForm.do?lob=<bean:write name='image'
property='lob'/>
&unitnbr=<bean:write name='image' property='unitnbr'/>
&onbase_dns=<bean:write name='image' property='onbase_dns'/>" >
<bean:write name="image" property="lob"/></a></td>
<td><bean:write name="image" property="unitnbr"/></td>
<td><bean:write name="image" property="onbase_dns"/></td>
</tr>
</logic:iterate>
</table>
 Logic Tags
• The Logic tag library contains tags that
are useful in managing conditional
generation of output text, looping over
object collections for repetitive
generation of output text, and
application flow management.
• Can do value comparison, substring
matching, etc
 Logic Tags - Example

<html:html>
<head>
<title><bean:message key="imagebrokerlink.title"/></title>
<META name="GENERATOR" content="IBM WebSphere Studio">
</head>
<body>
<html:form action="/ImageLocationForm" >
<center>
<font size=3>
<br>
<b>
<logic:notEqual property="action" name="ImageLocationForm" value="Insert">
<bean:message key="imagelocationdetail.title"/>
</logic:notEqual>
<logic:equal property="action" name="ImageLocationForm" value="Insert">
<bean:message key="imagelocationinsert.title"/>
</logic:equal>
…
…
 Template Tags
• The Template tag library contains three
tags: put, get, and insert. Put tags put
content into request scope, which is
retrieved by a get tag in a different JSP
page (the template). That template is
included with the insert tag.
 Custom Tags

<%@ taglib uri="WEB-INF/imagebroker.tld" prefix="broker" %>

<table width=750 cellspacing=0 cellpadding=2 border=2 >
<tr>
<td><broker:form
lob='<%=test.getLob()%>'
unitnbr='<%=test.getUnitnbr()%>'
userid='<%=test.getUserid()%>' >
<broker:doctype value="Invoice"/>
<broker:keyword name="CompanyNbr" value="55555"/>
<broker:keyword name="PONbr" value="M12345"/>
<broker:constraint name="FromDate" value="02/02/2002"/>
<broker:constraint name="ToDate" value="02/28/2002"/>
Image Broker Link Test
</broker:form>
</td>
</tr>
</table>
 Custom Tags – tld File

<tag>
<name>doctype</name>
<tagclass>com.pri.brokertag.ImageBrokerDoctype</tagclass>
<attribute>
<name>value</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
 Custom Tags – Tag Class

public class ImageBrokerDoctype extends TagSupport {

private String value = null;
public int doStartTag() throws JspException
{
Hashtable ht = null;
String keyword_count = null;
int iCnt = 0;
HttpServletRequest request = (HttpServletRequest)
pageContext.getRequest();
ht = (Hashtable) request.getAttribute("keyword_parms");
keyword_count = (String)
request.getAttribute("queryobject_count");
iCnt ++;
ht.put("QueryObject" + iCnt, value);
request.setAttribute("keyword_parms", ht);
request.setAttribute("queryobject_count", new String(new
Integer(iCnt).toString()));
return EVAL_PAGE; }
}
 STRUTS Configuration File

• The developer's responsibility is to

create an XML file named struts-
config.xml, and place it in the WEB-INF
directory of your application. This format
of this document is constrained by it's
definition in "struts-config_1_0.dtd". The
outermost XML element must be
<struts-config>.
• Inside of the <struts-config> element, there are two important elements
that are used to describe your actions:
<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: 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 your form bean.
<action-mappings>
This section contains your action definitions. You use an <action>
element for each of your actions you would like to define. Each action
element requires the following attributes to be defined:
• 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
 Struts-config.xml
• <?xml version="1.0" encoding="ISO-8859-1" ?>
• <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration
1.0//EN"
• "http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">
• <struts-config>
• <!-- ========== Form Bean Definitions =================================== -->
• <form-beans>
• <form-bean name="CryptForm" type="com.pri.imagebrokerWeb.CryptForm" />
• </form-beans>
• <!-- ========== Global Forward Definitions ============================== -->
• <global-forwards>
• <forward name="start" path="/index.html"/>
• </global-forwards>
• <!-- ========== Action Mapping Definitions ============================== -->
• <action-mappings>
• <action path="/CryptForm" type="com.pri.imagebrokerWeb.CryptAction"
• name="CryptForm" scope="request" input="/pgCrypt.jsp">
• <forward name="encrypt" path="/pgCryptDisplay.jsp"/>
• </action>
• </action-mappings>
• </struts-config>
 Web Application Descriptor File

• The final step in setting up the

application is to configure the
application deployment descriptor
(stored in file WEB-INF/web.xml) to
include all the Struts components that
are required. Using the deployment
descriptor for the example application
as a guide, we see that the following
entries need to be created or modified.
 web.xml File

• <?xml version="1.0" encoding="ISO-8859-1"?>

• <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application
2.2//EN"
• "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">
• <web-app id="WebApp">
• <display-name>imagebrokerWeb</display-name>
• <!-- Action Servlet Configuration -->
• <servlet id="Servlet_1">
• <servlet-name>action</servlet-name>
• <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
• <init-param>
• <param-name>application</param-name><param-value>imagebrokerWeb</param-
value>
• </init-param>
• <init-param>
• <param-name>config</param-name><param-value>WEB-INF/struts-
config.xml</param-value>
• </init-param>
• </servlet>
 web.xml File - continued

<!-- Action Servlet Mapping -->

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

<!-- The Welcome File List -->

<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
 web.xml File - continued

<!-- Struts Tag Library Descriptors -->

<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>
 Application Resources File

• error.cryptvalue.required=<li>You must enter some text.</li>

• error.lob.required=<li>You must enter the Line of Business.</li>
• error.unitnbr.required=<li>You must enter the Unit Number.</li>
• error.onbase_dns.required=<li>You must enter the OnBase
DNS.</li>
• imagebroker.linkname=Project Refinery, Inc.
• imagebroker.title=pri Image Broker
• imagebrokerlink.title=pri Image Broker Link Test
• imagelocationlist.title=Image Location List
• imagelocationdetail.title=Image Location Detail
• imagelocationinsert.title=Image Location Insert
• errors.header=
• errors.footer=
 Resources
• Jakarta Struts Web Site
http://jakarta.apache.org/struts/index.htm
• Struts Community Resources
http://struts.sourceforge.net/community/tutorials.html
• Learn Technology
http://www.learntechnology.net/
• Demystifying Jakarta Struts
http://www.coreservlets.com/Apache-Struts-Tutorial/
 Books

Chuck Cavaness James Holmes

 Books…

Ted Husted
 Special thanks

AppLabs Technologies Pvt. Ltd.

Coordinating for TWINCLING Saturday Meet
(TSM) Providing LCD projector and Meeting
space.

http://www.applabs.com/
 About Us

India's first, independent, "not-for-profit",

OpenSource software development &
promotion society.
www.twincling.org
groups.yahoo.com/group/twincling