Struts is an open-source
Java web application framework whose architecture is based on the Model-View-Controller
design pattern in which requests are routed through a controller that provides
overall application management and dispatches the requests to application
components. JavaServer Faces technology is a user-interface framework for
Java web applications. It is focussed on the view tier of an MVC-based
architecture. The Struts and JavaServer Faces technology frameworks do
have some overlapping functionality; however each framework has its advantages,
and developers can use certain features of both frameworks in a single
The primary advantages of Struts as compared to JavaServer Faces technology are
- Because Struts is a web
application framework, it has a more sophisticated controller architecture
than does JavaServer Faces technology. It is more sophisticated partly
because the application developer can access the controller by creating an
Action object that can integrate with the controller, whereas JavaServer
Faces technology does not allow access to the controller. In addition,
the Struts controller can do things like access control on each Action based
on user roles. This functionality is not provided by JavaServer Faces
- Struts includes a powerful layout management framework, called Tiles,
which allows you to create templates that you can reuse across multiple
pages, thus enabling you to establish an overall look-and-feel for an
- The Struts validation framework includes a larger set of standard
validators, which automatically generate both server-side and client-side
validation code based on a set of rules in a configuration file. You can
also create custom validators and easily include them in your application by
adding definitions of them in your configuration file.
The greatest advantage that JavaServer Faces technology has over Struts is
its flexible, extensible UI component model, which includes:
- A standard component API for specifying the state and behavior of a wide
range of components, including simple components, such as input fields, and
more complex components, such as scrollable data tables. Developers
can also create their own components based on these APIs, and many third
parties have already done so and have made their component libraries
- A separate rendering model that defines how to render the components in
various ways. For example, a component used for selecting an item from
a list can be rendered as a menu or a set of radio buttons.
- An event and listener model that defines how to handle events generated by
activating a component, such as what to do when a user clicks a button.
- Conversion and validation models for converting and validating component
Because the JavaServer Faces technology architecture separates the definition
of a component from its rendering, you can render your components in different
ways or even to different clients, such as a WML client. Moreover,
the extensible component APIs of JavaServer Faces technology allow you to extend
the standard set of components and create entirely new components. None of
this is possible with Struts. In fact, Struts has no notion of server-side
components, which also means that it has no event model for responding to
component events and no facility for saving and restoring component state.
While Struts does have a useful tag library for rendering components on the
page, these components have no object representation on the server and
they can only be rendered to an HTML client.
Another distinct advantage of JavaServer Faces technology is that it is
standard, which means that it has been developed through the Java Community
Process (JCP) and has been designed to allow easy integration into tools.
As a result, JavaServer Faces technology already has wide industry support and
is being leveraged by several web application development IDEs (such as Sun
Java Studio Creator).
Because both JavaServer Faces technology and Struts contribute such valuable
features, developers might want to be able to use both of them in a single
application. Developers might want to integrate the flexible component
model of JavaServer Faces technology into their existing Struts applications
while continuing to use the Struts controller architecture. Similarly,
developers who have JavaServer Faces technology applications might want to
integrate the more powerful client-side validation mechanism and Tiles layout
framework found in the Struts architecture into their applications. These
goals can be accomplished by using the stuts-faces integration library, which
you can download from here.