Struts 2 Tutorial: Introduction to Struts 2 Framework

Let us begin Part 1 of 7-parts series tutorials on Struts 2 Framework. In these tutorials
we will discuss the Introduction of Struts2 framework, validation framework, the
interceptors in struts 2, tiles plugin and its application with example, a file upload
example and struts2 ajax example.

Struts 2 Tutorial List

• Part 1: Introduction to Struts 2

• Part 2: Create Hello World Application in Struts 2
• Part 3: Struts 2 Validation Framework Tutorial with Example
• Part 4: Struts 2 Tiles Plugin Tutorial with Example
• Part 5: Struts 2 Interceptors Tutorial with Example
• Part 6: Struts 2 File Upload and Save Example
• Part 7: Struts 2 Ajax Tutorial with Example

Introduction of Struts 2 Framework

Apache Struts 2 is an elegant, extensible framework for creating enterprise-ready Java
web applications. The framework is designed to streamline the full development cycle,
from building, to deploying, to maintaining applications over time.

Apache Struts2 was originally known as WebWork 2. After working independently for
several years, the WebWork and Struts communities joined forces to create Struts2.
This new version of Struts is simpler to use and closer to how Struts was always meant
to be.

Struts 2 is a pull-MVC framework. i.e. the data that is to be displayed to user has to be
pulled from the Action.

Struts2 supports annotation based configurations which are easy to create and more
intuitive. Action class in Struts 2 act as the model in the web application. Unlike Struts,
Struts 2 Action class are plain POJO objects thus simplifying the testing of the code.
Struts2 also comes with power APIs to configure Interceptors that reduce greatly the
coupling in application. The view part of Struts 2 is highly configurable and it supports
different result-types such as Velocity, FreeMarker, JSP, etc.

Architecture of Struts 2
Struts 2 Architecture is based on WebWork 2 framework. It leverages the standard JEE
technologies such as Java Filters, JavaBeans, ResourceBundles, Locales, XML etc in its
architecture.
Following is its framework diagram.

Image Courtesy: struts.apache.org

1. The normal lifecycle of struts begins when the request is sent from client. This
results invoke the servlet container which in turn is passed through standard filter
chain.
2. The FilterDispatcher filter is called which consults the ActionMapper to
determine whether an Action should be invoked.
3. If ActionMapper finds an Action to be invoked, the FilterDispatcher delegates
control to ActionProxy.
 4. ActionProxy reads the configuration file such as struts.xml. ActionProxy creates
an instance of ActionInvocation class and delegates the control.
5. ActionInvocation is responsible for command pattern implementation. It invokes
the Interceptors one by one (if required) and then invoke the Action.
6. Once the Action returns, the ActionInvocation is responsible for looking up the
proper result associated with the Action result code mapped in struts.xml.
7. The Interceptors are executed again in reverse order and the response is
returned to the Filter (In most cases to FilterDispatcher). And the result is then sent
to the servlet container which in turns send it back to client.

Request Processing Lifecycle

The request processing lifecycle of Struts2 framework is pretty much discussed in above
section where we saw the architecture of Struts 2 framework.

1. Request is generated by user and sent to Servlet container.

2. Servlet container invokes FilterDispatcher filter which in turn determines
appropriate action.
3. One by one Intercetors are applied before calling the Action. Interceptors
performs tasks such as Logging, Validation, File Upload, Double-submit guard etc.
4. Action is executed and the Result is generated by Action.
5. The output of Action is rendered in the view (JSP, Velocity, etc) and the result is
returned to the user.

AJAX Support in Struts 2

AJAX is a well known term in web development. It is now possible to write desktop like
web2.0 application using AJAX. Untill Struts 1.x, developer had to write and maintain the
code in javascript to add AJAX support.
But now Struts 2 gives you Ajax ‘out of the box’. No writing of javascript, no debugging
against various browsers; just configure and go.

Struts 2 comes with highly configurable AJAX tag library which can be used directly
without writing JavaScript code. Struts 2 also support Dojo library. Its now very easy to
add AJAX enabled feature such as Autocomplete to your web application.
Related: Introduction to DOJO Toolkit

Comparison of Struts 1 and Struts 2

Let us see the basic difference between Struts 1 and 2 framework.

1. Unlike Struts 1, Struts 2 does not need to implement Action class. The Action in
Struts 2 is a POJO object. Thus making it easy to unit test the code.
2. Struts 1 Actions are singletons and must be thread-safe since there will only be
one instance of a class to handle all requests for that Action. Struts 2 Action objects
are instantiated for each request, so there are no thread-safety issues.
3. Struts 1 Actions have dependencies on the servlet API since the
HttpServletRequest and HttpServletResponse is passed to the execute method
when an Action is invoked. Struts 2 Actions are not coupled to a container. Most
often the servlet contexts are represented as simple Maps, allowing Actions to be
tested in isolation.
4. Struts 1 uses an ActionForm object to capture input. Like Actions, all
ActionForms must extend a base class. Since other JavaBeans cannot be used as
ActionForms, developers often create redundant classes to capture input. Struts 2
uses Action properties as input properties, eliminating the need for a second input
object. Input properties may be rich object types which may have their own
properties.
5. Struts 1 integrates with JSTL, so it uses the JSTL EL. The EL has basic object
graph traversal, but relatively weak collection and indexed property support. Struts 2
can use JSTL, but the framework also supports a more powerful and flexible
expression language called “Object Graph Notation Language” (OGNL).
6. Struts 1 uses the standard JSP mechanism for binding objects into the page
context for access. Struts 2 uses a “ValueStack” technology so that the taglibs can
access values without coupling your view to the object type it is rendering.
7. Struts 1 supports separate Request Processors (lifecycles) for each module, but
all the Actions in the module must share the same lifecycle. Struts 2 supports
creating different lifecycles on a per Action basis via Interceptor Stacks. Custom
stacks can be created and used with different Actions, as needed.