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 Device or browser type User preferences / personalization Internationalization and localization requirements Accessibility requirements

Actual content varies depending on:

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:

ActionForm Standard JavaBean design pattern DynaActionForm Property names and types defined in Struts configuration file

In addition to properties, form beans define two standard methods:

reset() -- Reset form properties to initial state validate() -- Perform field-level validations
Allows redisplay of invalid input

Form bean properties are typically Strings

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.MemoryDatabasePlug In> <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.)
Requires changes to view layer and strutsconfig.xml file only! Plugs in to RequestProcessor APIs

Struts will provide an integration library:

Resources

This Presentation Online

StarOffice 6.0:

http://www.apache.org/~craigmcc/apachecon-2002-struts.sxi http://www.apache.org/~craigmcc/apachecon-2002-struts.ppt

Powerpoint:

Internet Technologies

Hypertext Markup Language (HTML) 4.01:

http://www.w3.org/TR/html4/ http://www.ietf.org/rfc/rfc2616.txt http://www.ietf.org/rfc/rfc2396.txt

Hypertext Transfer Protocol (HTTP) 1.1: Uniform Resource Identifiers (URI):

Model Layer Standard Java APIs

JavaBeans:

http://java.sun.com/products/javabeans/ http://java.sun.com/products/jdbc/ http://java.sun.com/products/jdo/ http://jcp.org/jsr/detail/12.jsp http://java.sun.com/products/jndi/ http://java.sun.com/products/ejb/

Java Database Connectivity (JDBC): Java Data Objects:

Java Naming and Directory Interface:

Enterprise JavaBeans (EJB):

Model Layer Persistence Frameworks

Castor:

http://castor.exolab.org/ http://java.sun.com/products/jdo/ http://jakarta.apache.org/ojb/

Java Data Objects: Object/Relational Bridge: Torque:

http://jakarta.apache.org/turbine/torque/

View Layer Standard Java APIs

Servlets:

http://java.sun.com/products/servlet/ http://java.sun.com/products/jsp/ http://java.sun.com/products/jsp/jstl/

JavaServer Pages (JSP): JSP Standard Tag Library (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/ 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

Recent Books About Struts:

Design Patterns Resources

The Java Blueprints Web Site:

http://java.sun.com/blueprints/ 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

Design Patterns Books:

Q&A