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

2. Session Outline ● Web Applications Backgrounder ● The Model-View-Controller Architecture ● The Struts Framework ● Building A Web Application With Struts ● Resources

3. Web Applications Backgrounder

4. ● 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

5. 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 ● This works fine for a Guest Book app, but what about something bigger?

6. 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 JavaBeans TM (EJBs) ● Application Deployment – Networks, firewalls, public key infrastructures, load balancing, failover ● We need a fundamental organizing principle: ● The Model-View-Controller (MVC) architecture

7. The Model-View-Controller (MVC) Architecture

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

9. 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)

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

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

12. The Struts Framework – An Implementation of the MVC Architecture

13. The Struts Framework – Architecture

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

15. 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 ● Form bean properties are typically Strings ● Allows redisplay of invalid input

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

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

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

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

20. 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 support

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

22. The Struts Framework – Controller Layer ● Standard Request Processing Lifecycle 1: ● processLocale() -- Record user's locale preference (if not already present) ● processPreprocess() -- general purpose pre- processing hook ● processMapping() -- select Action to be utilized ● processRoles() -- perform security role-based restrictions on action execution ● processActionForm() -- Create or acquire an appropriate ActionForm instance

23. 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)

24. The Struts Framework – Controller Layer ● XML Configuration Document (/WEB- INF/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

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

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

27. Building Web Applications With Struts

28. ● 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

29. 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; }

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

31. Sample Application – Model Layer (Business Logic) ● Two common Struts design patterns illustrated ● View --> View --> Action ● Welcome Page has link to logon page: ●... ● 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

32. Sample Application – View Layer (logon.jsp) <%@ taglib uri=”/WEB-INF/struts-bean.tld” prefix=”bean” %> <%@ taglib uri=”/WEB-INF/struts-html.tld” prefix=”html” %>

33. Sample Application – View Layer (logon.jsp) <html:form action=”/logon” focus=”username” onsubmit=”return validateLogonForm(this);”>

34. Sample Application – View Layer (logon.jsp) <html:password property=”password” size=”16”/> <html:javascript formName=”logonForm” dynamicJavascript=”true” staticJavascript=”false”/>

35. Sample Application – Controller Layer ● No application logic required – Struts does everything for you :-) ● Controller functionality is configured via XML- based files: ● struts-config.xml – Struts controller configuration ● validation.xml – Validator framework configuration ● web.xml – Web application configuration

36. Sample Application – Struts Configuration (struts-config.xml)... <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 name=”registrationForm” type=” org.apache.webapp.example.RegistrationForm ”/>...

37. Sample Application – Struts Configuration (struts-config.xml) <forward name=”registration” path=”/registration.jsp”/> <forward name=”success” path=”/mainMenu.jsp”/>

38. Sample Application – Struts Configuration (struts-config.xml) <action path=”/editRegistration” type=” org.apache.struts.webapp.example.EditRegistrationAction ” name=”registrationForm” scope=”request” validate=”false”> <forward name=”success” path=”/registration.jsp”/> <action path=”/saveRegistration” type=” org.apache.struts.webapp.example.SaveRegistrationAction ” name=”registrationForm” scope=”request” validate=”true” input=”registration”/>

39. Sample Application – Struts Configuration (struts-config.xml) <action path=”/logon” type=” org.apache.struts.webapp.example.LogonAction ” input=”request” name=”logonForm” scope=”request”/>... <set-property property=”inputForward” value=”true”/> <message-resources parameter=” org.apache.struts.example.ApplicationResources ”/>

40. Sample Application – Struts Configuration (struts-config.xml) <set-property property=”pathname” value=”/WEB-INF/database.xml”/> <set-property property=”pathnames” value=”/WEB-INF/validator-rules.xml, /WEB-INF/validation.xml”/>

41. Sample Application – Struts Configuration (validation.xml) <field property=”username” depends=”minlength,...”> <arg1 key=”${var:minlength}” name=”minlength” resource=”false”/> minlength 3.........

42. Sample Application – Webapp Configuration (web.xml) Controller org.apache.struts.action.ActionServlet config /WEB-INF/struts-config.xml 1

43. Sample Application – Webapp Configuration (web.xml) Controller *.do...

44. Current Events

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

46. 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)

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

48. 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 struts- config.xml file only! ● Plugs in to RequestProcessor APIs

49. Resources

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

51. Internet Technologies ● Hypertext Markup Language (HTML) 4.01: ● http://www.w3.org/TR/html4/ ● Hypertext Transfer Protocol (HTTP) 1.1: ● http://www.ietf.org/rfc/rfc2616.txt ● Uniform Resource Identifiers (URI): ● http://www.ietf.org/rfc/rfc2396.txt

52. Model Layer – Standard Java APIs ● JavaBeans: ● http://java.sun.com/products/javabeans/ ● Java Database Connectivity (JDBC): ● http://java.sun.com/products/jdbc/ ● Java Data Objects: ● http://java.sun.com/products/jdo/ ● http://jcp.org/jsr/detail/12.jsp ● Java Naming and Directory Interface: ● http://java.sun.com/products/jndi/ ● Enterprise JavaBeans (EJB): ● http://java.sun.com/products/ejb/

53. Model Layer – Persistence Frameworks ● Castor: ● http://castor.exolab.org/ ● Java Data Objects: ● http://java.sun.com/products/jdo/ ● Object/Relational Bridge: ● http://jakarta.apache.org/ojb/ ● Torque: ● http://jakarta.apache.org/turbine/torque/

54. View Layer – Standard Java APIs ● Servlets: ● http://java.sun.com/products/servlet/ ● JavaServer Pages (JSP): ● http://java.sun.com/products/jsp/ ● JSP Standard Tag Library (JSTL): ● http://java.sun.com/products/jsp/jstl/ ● JavaServer Faces: ● http://java.sun.com/j2ee/javaserverfaces/ ● http://jcp.org/jsr/detail/127.jsp

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

56. 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; Addison- Wesley ● Alur, Deepak (et. al.); Core J2EE Patterns: Best Practices and Design Strategies; Prentice Hall

57. Q & A