Transcript Building Web Applications With The Struts Framework Session WE06 – 11/20/2002 – 10:00-11:00 Craig R.

Building Web Applications With
The Struts Framework
Session WE06 – 11/20/2002 – 10:00-11:00
Craig R. McClanahan
Senior Staff Engineer
Sun Microsystems, Inc.
Session Outline
●
●
●
●
●
Web Applications Backgrounder
The Model-View-Controller Architecture
The Struts Framework
Building A Web Application With Struts
Resources
Web Applications Backgrounder
Web Applications Backgrounder
●
Web applications run over the HTTP
protocol:
●
●
●
Request/response oriented
Stateless
Web applications use varied presentation
(markup) languages, and talk to varied
client hardware devices:
●
●
●
“Standard HTML” -- not!
Varying dynamic and JavaScript capabilities
Wireless devices vary in capabilities, language
dialect, and input device support
Simple Solutions ... for Simple
Problems
●
●
For relatively simple applications, a simple
architecture works fine
For each page in the user interface ...
●
●
Create a servlet, JSP page, or something
similar
The page includes:
Logic to create the user interface
Logic to retrieve required information from the
database
● Logic to perform the appropriate business
transaction
● Logic to update the corresponding database
information
●
●
●
And it's all mixed together in one source file
What About Large Scale Applications?
●
Disparate skill sets required:
●
●
●
●
●
Presentation Layer-- User interface design,
visual appearance, interaction model
Application Layer – Functional business logic
to perform required transactions
Persistence Layer – Databases, directory
servers, messaging, Enterprise JavaBeansTM
(EJBs)
Application Deployment – Networks, firewalls,
public key infrastructures, load balancing,
failover
We need a fundamental organizing
principle:
The Model-View-Controller
(MVC) Architecture
The Model-View-Controller
Architecture
●
Divides the overall functionality of an
application into three layers:
●
●
●
Model Layer – Contains the functional
business logic of the application, as well as a
representation of the persistently stored data
backing the application
View Layer – Contains the user interface,
including mechanisms to accept user input
and render results
Controller Layer – Contains the logic that
manages the flow of individual requests,
dispatching to the appropriate business logic
component
The Model Layer
●
Functional business logic:
●
●
●
●
Should be modelled as JavaBeans or Session
EJBs
Should be reusable in non-web environments
API exposes public methods for each logical
unit of work (while hiding the details)
Persistent data storage:
●
●
●
Should manage permanent storage of
application data
Typically shared across many applications
API should expose data retrieval and storage
operations (while hiding the mechanisms)
The View Layer
●
Creation of the user interface:
●
●
●
Typically in HTML or an XML-based dialect
Normally a combination of static and dynamic
content
Actual content varies depending on:
●
●
●
●
Device or browser type
User preferences / personalization
Internationalization and localization requirements
Accessibility requirements
The Controller Layer
●
Incoming requests flow through a common
path:
●
●
●
●
●
●
●
Received by common component
Standardized request pre-processing
Dispatch to request-specific model component
(business logic)
Forward to business-logic-specified view
component
Standardized request post-processing
Often called “Model 2 Design” in the
JSP/Servlet community
In modern design pattern terminology, Struts
implements the front controller pattern.
The Struts Framework – An
Implementation of the MVC
Architecture
The Struts Framework – Architecture
The Struts Framework – Model Layer
●
Struts does not restrict implementation
techniques for model layer
●
●
●
●
●
JDBC-accessed databases
Enterprise JavaBeans
O-R mapping tools
Optional JDBC connection pool available
Common design pattern:
●
●
●
Action acquires information from persistence tier
Exposes information as request/session attributes
View layer pulls data from attributes for display
The Struts Framework – View Layer
●
Form Bean maintains state of form input
fields across requests:
●
●
●
In addition to properties, form beans define
two standard methods:
●
●
●
ActionForm – Standard JavaBean design pattern
DynaActionForm – Property names and types
defined in Struts configuration file
reset() -- Reset form properties to initial state
validate() -- Perform field-level validations
Form bean properties are typically Strings
●
Allows redisplay of invalid input
The Struts Framework – View Layer
●
Internationalization Support enables
locale-specific applications
●
●
Locale – Standard Java class representing a
choice of language and/or country
MessageFormat – Standard Java class
representing an individual message with
replaceable parameters:
●
●
●
“{0} is not a valid credit rating”
MessageResources – Struts abstraction
around sets of messages for supported
locales
ActionErrors / ActionMessages – Struts
collections of localized messages
The Struts Framework – View Layer
●
JSP Custom Tag Libraries – If you are
using JSP pages for your presentation
●
●
●
●
struts-bean.tld – Fundamental bean
manipulation and internationalization
struts-html.tld – “Smart” HTML elements
struts-logic.tld – Basic conditionals and
iteration
struts-template.tld – Basic layout management
The Struts Framework – View Layer
●
Standard tag libraries added in Struts 1.1:
●
●
●
struts-nested.tld -- “Nested” variants of
standard tags that resolve relative references
against beans
struts-tiles.tld – Full features layout
management library
Contributed libraries added in Struts 1.1:
●
struts-xxx-el.tld – Versions of standard Struts
tag libraries that support the expression
language syntax of JSP Standard Tag Library
The Struts Framework – View Layer
●
Validation Framework
●
●
●
●
No-code-required field level validations
Configured in an XML document included in
the web application
Optionally generates client side JavaScript to
enforce validation rules
Extensible architecture
The Struts Framework – Controller Layer
●
●
ActionServlet – Standard implementation
of controller
At application startup, reads configuration
file and initializes resources
●
●
●
●
[Struts 1.1] PlugIn – General start/stop hook
On each request, implements the standard
Struts request processing lifecycle (in
Struts 1.1, implemented in
RequestProcessor)
Specialization / customization via
subclassing
[Struts 1.1] Sub-application modules
The Struts Framework – Controller
Layer
●
Action – Standard base class for business
logic components and adapters:
●
●
●
●
Mapped to logical names by request processor
Single instance per application (must be
thread safe)
Instantiated as needed, like servlets
Implements the “Command Pattern”
●
●
●
execute() -- Invoked for each request
Can (but typically does not) create response
content directly
Typically returns ActionForward to select
resource to prepare response
The Struts Framework – Controller
Layer
●
Standard Request Processing Lifecycle 1:
●
●
●
●
●
processLocale() -- Record user's locale
preference (if not already present)
processPreprocess() -- general purpose preprocessing hook
processMapping() -- select Action to be
utilized
processRoles() -- perform security role-based
restrictions on action execution
processActionForm() -- Create or acquire an
appropriate ActionForm instance
The Struts Framework – Controller
Layer
●
Standard Request Processing Lifecycle 2:
●
●
●
●
●
processPopulate() -- Copy the request
parameters into the form bean properties
processValidate() -- Call form bean's validate()
method
processActionCreate() -- Create or acquire an
appropriate Action instance
processActionPerform() -- Call action's
execute() method
processActionForward() -- Process returned
ActionForward instance (if any)
The Struts Framework – Controller Layer
●
XML Configuration Document (/WEBINF/struts-config.xml)
●
●
●
●
●
Standard place to configure all aspects of the
application's behavior
DTD included for optional (but recommended)
validation
Logical-to-physical mappings for Actions,
ActionForms, and ActionForwards
General configuration settings
[Struts 1.1] Configuration Document per
module if more than one
The Struts Framework – Commons
Libraries
●
Non-Struts Specific Logic Factored Out:
●
●
●
●
●
commons-beanutils – Generic bean property
manipulation
commons-collections – Extensions to standard
Java2 collections classes
commons-dbcp – Optional JDBC connection pool
commons-digester – XML parsing for
configuration files
commons-fileupload – Support library for HTML
file uploads
The Struts Framework – Commons
Libraries
●
Non-Struts Specific Logic Factored Out:
●
●
●
●
commons-logging – Application logging wrapper
commons-pool – Object pooling library
commons-resources – Message resources
support library
Commons-validator – Field validation framework
Building Web Applications With
Struts
Building Web Applications With Struts
●
●
Now that we understand the architecture of
Struts, let's look at parts of an example app
that is built with it
Struts includes a canonical example that is
useful in determining whether you have
installed things correctly
●
●
struts-example.war
Application models (part of) an email portal
site that lets you maintain multiple
subscriptions
Sample Application – Model Layer
(Persistence Tier)
●
Modelled via a Data Access Object (DAO)
●
org.apache.struts.webapp.example.UserDatabase
public interface UserDatabase {
public User createUser(String username);
public void close() throws Exception;
public User findUser(String username);
public User[] findUsers();
public void open() throws Exception;
public void removeUser(User user);
public void save() throws Exception;
}
Sample Application – Model Layer
(Persistence Tier)
●
Default implementation based on loading an
XML document into memory:
●
●
●
o.a.s.e.memory.MemoryUserDatabase
JDBC-based (or LDAP-based) implementation
is easy to imagine, and would be transparent
to the business logic
Implementation selection implemented via a
PlugIn ... see configuration file example later
Sample Application – Model Layer
(Business Logic)
●
●
Two common Struts design patterns illustrated
View --> View --> Action
●
Welcome Page has link to logon page:
●
●
●
●
<html:link page=”/logon.jsp”>...</html:link>
Logon page instantiates LogonForm bean
Form submit goes to “/logon” action
View --> Action --> View --> Action
●
●
●
Setup action “/editRegistration?action=Edit” pulls
data from “database” and populates form bean
Registration page “/registration.jsp” displays
current data
Form submit goes to “/saveRegistration” action
Sample Application – View Layer
(logon.jsp)
<%@ page contentType=”text/html;charset=”UTF-8” %>
<%@ taglib uri=”/WEB-INF/struts-bean.tld”
prefix=”bean” %>
<%@ taglib uri=”/WEB-INF/struts-html.tld”
prefix=”html” %>
<html:html locale=”true”>
<head>
<title>
<bean:message key=”logon.title”/>
</title>
<html:base/>
</head>
Sample Application – View Layer
(logon.jsp)
<body bgcolor=”white”>
<html:errors/>
<html:form action=”/logon” focus=”username”
onsubmit=”return validateLogonForm(this);”>
<table border=”0” width=”100%”>
<tr>
<th align=”right”>
<bean:message key=”prompt.username”/>
</th>
<td align=”left”>
<html:text property=”username” size=”16”/>
</td>
</tr>
Sample Application – View Layer
(logon.jsp)
<tr>
<th align=”right”>
<bean:message key=”prompt.password”/>
</th>
<td align=”left”>
<html:password property=”password”
size=”16”/>
</td>
</tr>
</table></html:form>
<html:javascript formName=”logonForm”
dynamicJavascript=”true”
staticJavascript=”false”/>
<script language=”Javascript” .../>
</body></html:html>
Sample Application – Controller Layer
●
●
No application logic required – Struts does
everything for you :-)
Controller functionality is configured via XMLbased files:
●
●
●
struts-config.xml – Struts controller configuration
validation.xml – Validator framework configuration
web.xml – Web application configuration
Sample Application – Struts
Configuration (struts-config.xml)
<struts-config>
<form-beans>
...
<form-bean name=”logonForm”
type=”org.apache.struts.action.DynaActionForm”>
<form-property name=”username”
type=”java.lang.String”/>
<form-property name=”password”
type=”java.lang.String”/>
</form-bean>
<form-bean name=”registrationForm”
type=”org.apache.webapp.example.RegistrationForm”/>
...
</form-beans>
Sample Application – Struts
Configuration (struts-config.xml)
<global-forwards>
<forward name=”logoff” path=”/logoff.do”/>
<forward name=”logon”
path=”/logon.do”/>
<forward name=”registration”
path=”/registration.jsp”/>
<forward name=”success”
path=”/mainMenu.jsp”/>
</global-forwards>
Sample Application – Struts
Configuration (struts-config.xml)
<action-mappings>
<action path=”/editRegistration”
type=”org.apache.struts.webapp.example.EditRegistrationAction”
name=”registrationForm”
scope=”request” validate=”false”>
<forward name=”success”
path=”/registration.jsp”/>
</action>
<action path=”/saveRegistration”
type=”org.apache.struts.webapp.example.SaveRegistrationAction”
name=”registrationForm”
scope=”request” validate=”true”
input=”registration”/>
Sample Application – Struts
Configuration (struts-config.xml)
<action path=”/logon”
type=”org.apache.struts.webapp.example.LogonAction”
input=”request”
name=”logonForm”
scope=”request”/>
...
</action-mappings>
<controller>
<set-property property=”inputForward”
value=”true”/>
</controller>
<message-resources
parameter=”org.apache.struts.example.ApplicationResources”/>
Sample Application – Struts
Configuration (struts-config.xml)
<plug-in
className=”org.apache.struts.webapp.example.memory.MemoryDataba
sePlugIn”>
<set-property property=”pathname”
value=”/WEB-INF/database.xml”/>
</plug-in>
<plug-in
className=”org.apache.struts.validator.ValidatorPlugIn”>
<set-property property=”pathnames”
value=”/WEB-INF/validator-rules.xml,
/WEB-INF/validation.xml”/>
</plug-in>
</struts-config>
Sample Application – Struts
Configuration (validation.xml)
<form-validation>
<formset>
<form name=”logonForm”>
<field property=”username”
depends=”minlength,...”>
<arg0 key=”prompt.username”/>
<arg1 key=”${var:minlength}”
name=”minlength”
resource=”false”/>
<var><var-name>minlength</var-name>
<var-value>3</var-value></var>
...
</field>
...
</form>
...
</formset>
</form-validation>
Sample Application – Webapp
Configuration (web.xml)
<web-app>
<servlet>
<servlet-name>Controller</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>
<load-on-startup> 1 </load-on-startup>
</servlet>
Sample Application – Webapp
Configuration (web.xml)
<servlet-mapping>
<servlet-name>Controller</servlet-name>
<url-pattern> *.do </url-pattern>
</servlet-mapping>
...
</web-app>
Current Events
Struts 1.1 Release
●
●
When? “Real Soon Now”
What new features?
●
●
●
●
●
●
●
Apache Commons Libraries
DynaActionForm
Declarative Exception Handling
Nested Tag Library
PlugIn API
Sub-Application Module Support
(Contributed) STRUTS-EL Tag Libraries
Struts and JSTL
●
JSP Standard Tag Library (JSTL) 1.0:
●
●
●
●
●
●
●
Expression language
(“${customer.address[“mailing”].city”)
General purpose actions (out, set, remove, catch)
Conditional actions (if, choose, when, otherwise)
Iterator actions (forEach, forTokens)
URL actions (import, url, redirect, param)
Internationalization actions (message, setLocale,
bundle, setBundle, message, param,
requestEncoding)
Formatting actions (timeZone, setTimeZone,
formatNumber, parseNumber, formatDate,
parseDate)
Struts and JSTL
●
JSP Standard Tag Library (JSTL) 1.0,
continued:
●
●
●
●
●
SQL actions (not relevant in an MVC framework
environment)
XML core actions (parse, out, set)
XML flow control actions (if, choose, when,
otherwise, forEach)
XML transform actions (transform, param)
The struts-xxx-el libraries are a bridge for
Struts developers who want to leverage JSTL
tags, and expression language syntax, now
Struts and JSF
●
●
JavaServer Faces (currently under
development in JSR-127)
Goals:
●
●
●
Standard GUI component framework for web
applications
RenderKits for different rendering environments
(browser vs. wireless device, different locales,
etc.)
Struts will provide an integration library:
●
●
Requires changes to view layer and strutsconfig.xml file only!
Plugs in to RequestProcessor APIs
Resources
This Presentation Online
●
StarOffice 6.0:
●
●
http://www.apache.org/~craigmcc/apachecon-2002-struts.sxi
Powerpoint:
●
http://www.apache.org/~craigmcc/apachecon-2002-struts.ppt
Internet Technologies
●
Hypertext Markup Language (HTML) 4.01:
●
●
Hypertext Transfer Protocol (HTTP) 1.1:
●
●
http://www.w3.org/TR/html4/
http://www.ietf.org/rfc/rfc2616.txt
Uniform Resource Identifiers (URI):
●
http://www.ietf.org/rfc/rfc2396.txt
Model Layer – Standard Java APIs
●
JavaBeans:
●
●
Java Database Connectivity (JDBC):
●
●
http://java.sun.com/products/jdo/
http://jcp.org/jsr/detail/12.jsp
Java Naming and Directory Interface:
●
●
http://java.sun.com/products/jdbc/
Java Data Objects:
●
●
●
http://java.sun.com/products/javabeans/
http://java.sun.com/products/jndi/
Enterprise JavaBeans (EJB):
●
http://java.sun.com/products/ejb/
Model Layer – Persistence Frameworks
●
Castor:
●
●
Java Data Objects:
●
●
http://java.sun.com/products/jdo/
Object/Relational Bridge:
●
●
http://castor.exolab.org/
http://jakarta.apache.org/ojb/
Torque:
●
http://jakarta.apache.org/turbine/torque/
View Layer – Standard Java APIs
●
Servlets:
●
●
JavaServer Pages (JSP):
●
●
http://java.sun.com/products/jsp/
JSP Standard Tag Library (JSTL):
●
●
http://java.sun.com/products/servlet/
http://java.sun.com/products/jsp/jstl/
JavaServer Faces:
●
●
http://java.sun.com/j2ee/javaserverfaces/
http://jcp.org/jsr/detail/127.jsp
Struts Resources
●
The Struts and Commons Web Sites:
●
●
●
http://jakarta.apache.org/struts/
http://jakarta.apache.org/commons/
Recent Books About Struts:
●
●
●
●
●
Cavaness, Chuck; Programming Jakarta Struts;
O'Reilly
Goodwill, James; Mastering Jakarta Struts; John
Wiley
Husted, Ted; Java Web Development With Struts;
Manning
Spielman, Sue; The Struts Framework: Practical
Guide for Programmers; Morgan Kaufman
Turner, James; Struts Kick Start; Sams
Design Patterns Resources
●
The Java Blueprints Web Site:
●
●
http://java.sun.com/blueprints/
Design Patterns Books:
●
●
Gamma, Erich (et. al.); Design Patterns: Elements
of Reusable Object-Oriented Software; AddisonWesley
Alur, Deepak (et. al.); Core J2EE Patterns: Best
Practices and Design Strategies; Prentice Hall
Q&A