Struts Intro Course

STRUTS
Part of the Jakarta Project

Sponsored by the
Apache Software Foundation
Developed by: Roger W Barnes of Project Refinery, Inc.
Introduction to Struts
Project Refinery, Inc. 1

STRUTS Objectives
 Course Overview
 Unit 1 - Model-View-Controller Design
Pattern
 Unit 2 - Model Components
 Unit 3 - View Components
 Unit 4 - Controller Components
 Unit 5 - Tag Libraries

STRUTS Objectives
 Unit 6 - STRUTS Configuration File

 Unit 7 - Web Application Descriptor File
 Unit 8 - Application Resources File
 Unit 9 – Resources

Model-View-Controller Design
Pattern
Unit 1

STRUTS MVC 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


3 Major Components in STRUTS

 Servletcontroller (Controller)
 Java Server Pages (View)
 Application Business Logic (Model)
 Controller bundles and routes HTTP

request to other objects in framework
 Controller parses configuration file

 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
Unit 2

STRUTS Model Components
 Model divided into concepts

 Internalstate of the system
 Actions that can change that state
 Internal state of system represented by

 JavaBeans
 Enterprise JavaBeans

 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

 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

 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

 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

 System State Beans

 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

 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

 Business Logic Beans - Continued

 For larger applications, these beans will
often be stateful or stateless Enterprise
JavaBeans (EJBs)

 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
Unit 3

STRUTS 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

 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>

 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

 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

 [logic] iterate repeats its tag body once for each element of
a specified collection (which can be an Enumeration, a
Hashtable, a Vector, or an array of objects)
 [logic] present depending on which attribute is specified,
this tag checks the current request, and evaluates the
nested body content of this tag only if the specified value is
present
 [logic] notPresent the companion tag to present, notPresent
provides the same functionality when the specified attribute
is not present

 Useful Presentation Tags – continued

 [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 a 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
Unit 4

STRUTS Controller Components
 Strutsincludes 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
Unit 5

STRUTS Tag Libraries
 HTML Tags
 Bean Tags
 Logic Tags
 Template Tags
 Custom Tags

HTML 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.

Bean Tags
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>
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.

Logic Tags
 For tags that do value comparisons (equal,
greaterEqual, greaterThan, lessEqual, lessThan,
notEqual), the following rules apply:
 The specified value is examined. If it can be converted
successfully to a double or a long, it is assumed that the
ultimate comparison will be numeric (either floating point or
integer). Otherwise, a String comparison will be performed.
 The variable to be compared to is retrieved, based on the
selector attribute(s) (cookie, header, name, parameter,
property) present on this tag. It will be converted to the
appropriate type for the comparison, as determined above.
 A request time exception will be thrown if the specified variable
cannot be retrieved, or has a null value.
 The specific comparison for this tag will be performed, and the
nested body content of this tag will be evaluated if the
comparison returns a true result.
Logic Tags
 For tags that do substring matching (match,
notMatch), the following rules apply:
 The specified variable is retrieved, based on the
selector attribute(s) (cookie, header, name,
parameter, property) present on this tag. The
variable is converted to a String, if necessary.
 A request time exception will be thrown if the specified
variable cannot be retrieved, or has a null value.
 The specified value is checked for existence as a
substring of the variable, in the position specified by
the location attribute, as follows: at the beginning (if
location is set to start), at the end (if location is set to
end), or anywhere (if location is not specified).

Logic Tags
Tag Name Description
Evaluate the nested body content of this tag if the requested variable is either
empty
null or an empty string.
Evaluate the nested body content of this tag if the requested variable is equal
equal
to the specified value.
forward Forward control to the page specified by the specified ActionForward entry.
Evaluate the nested body content of this tag if requested variable is greater
greaterEqual
than or equal to specified value.
Evaluate the nested body content of this tag if the requested variable is greater
greaterThan
than the specified value.
iterate Repeat the nested body content of this tag over a specified collection.
Evaluate the nested body content of this tag if requested variable is greater
lessEqual
than or equal to specified value.
Evaluate the nested body content of this tag if the requested variable is less
lessThan
than the specified value.
Evaluate the nested body content of this tag if specified value is an appropriate
match
substring of requested variable.
messagesNotPrese Generate the nested body content of this tag if the specified message is not
nt present in this request.
Generate the nested body content of this tag if the specified message is present
messagesPresent
in this request.
Evaluate the nested body content of this tag if the requested variable is neither
notEmpty
null nor an empty string.
Evaluate the nested body content of this tag if the requested variable is not
notEqual
equal to the specified value.
Evaluate the nested body content of tag if specified value not an appropriate
notMatch
substring of requested variable.
Generate the nested body content of this tag if the specified value is not
notPresent
present in this request.
Generate the nested body content of this tag if the specified value is present in
present
this request.
redirect Render an HTTP Redirect
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.

Template Tags
 Insert Inserts (includes, actually) a
template. Templates are JSP pages that
include parameterized content. That
content comes from put tags that are
children of insert tags.
 Put Puts content into request scope.
 Get Gets the content from request scope
that was put there by a put 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; }
} Project Refinery, Inc. 64
STRUTS Configuration File
Unit 6

 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-beans>
<form-bean name="CryptForm" type="com.pri.imagebrokerWeb.CryptForm" />
</form-beans>

<global-forwards>
<forward name="start" path="/index.html"/>
</global-forwards>

<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
Unit 7

Web.xml 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>

<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

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


<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>

Web.xml File - continued

<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
Unit 8

Application.properties 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
Unit 9

Resources
 Main Struts Web Site

 http://jakarta.apache.org/struts/index.html
 Struts User Guide
 http://jakarta.apache.org/struts/userGuide/index.html
 Various Struts Resources
 http://jakarta.apache.org/struts/resources.html
 Ted Husted Web Site
 http://www.husted.com/struts/

Struts Intro Course

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Struts Intro Course

Transféré par

Droits d'auteur :

Formats disponibles

STRUTS

Part of the Jakarta Project

Developed by: Roger W Barnes of Project Refinery, Inc.

Project Refinery, Inc. 1

Project Refinery, Inc. 2

 Unit 6 - STRUTS Configuration File

Project Refinery, Inc. 3

Project Refinery, Inc. 4

 Central controller mediates application flow

Project Refinery, Inc. 5

Project Refinery, Inc. 6

3 Major Components in STRUTS

 Application Business Logic (Model)

 Controller bundles and routes HTTP

Project Refinery, Inc. 7

 Configuration file contains action

Project Refinery, Inc. 8

Project Refinery, Inc. 9

 Model divided into concepts

 Internal state of system represented by

Project Refinery, Inc. 10

 JavaBeans and Scope

Project Refinery, Inc. 11

Project Refinery, Inc. 12

 When coding ActionForm beans consider:

Project Refinery, Inc. 13

Project Refinery, Inc. 14

 System State Beans

Project Refinery, Inc. 15

 Business Logic Beans

Project Refinery, Inc. 16

 Business Logic Beans - Continued

Project Refinery, Inc. 17

 Accessing Relational Databases

Project Refinery, Inc. 18

Project Refinery, Inc. 19

Project Refinery, Inc. 20

Project Refinery, Inc. 21

 Forms and FormBean interactions

Project Refinery, Inc. 22

<%@ page language="java" %>

Project Refinery, Inc. 23

 Building Forms with Struts

Project Refinery, Inc. 24

 Building Forms with Struts – continued

Project Refinery, Inc. 25

 Input field types supported

Project Refinery, Inc. 26

 Useful Presentation Tags

Project Refinery, Inc. 27

 Useful Presentation Tags – continued

Project Refinery, Inc. 28

 Automatic Form Validation

Project Refinery, Inc. 29

 Page Composition with Includes

Project Refinery, Inc. 30

 Page Composition with Includes – continued

Project Refinery, Inc. 31

Project Refinery, Inc. 32

 Strutsincludes a Servlet that

Project Refinery, Inc. 33

 Your primary responsibilities are:

Project Refinery, Inc. 34

Project Refinery, Inc. 35