Struts 2 Architecture and
Overview
Objectives:
1. Understand MVC and Struts 2
Architecture
2. Analyze Page-centric and
Servlet-centric Designs
3. Develop JSP Interactive
Interfaces
Topics








Introduction to Struts 2
Model-View-Controller Architecture
Struts and MVC
Architecting Web Applications
Page-centric Design
Servlet-centric Design
JSP Interactive Interfaces
FormBean
Struts Classic Project
 Combines JSPs and Servlets
 Targets a Model-View-Controller (MVC)
Architecture
 Conceived by Craig McClanahan in May 2000
 Support by Application Servers
 BEA
 GlassFish
 JBoss
 Apache’s Tomcat
Struts 2
 Apache Project
 Based on OpenSymphony WebWork framework
 Implements MVC
 Takes advantage of the lessons learned from
Struts Classic to present a cleaner implementation
of MVC
New Features
 Interceptors
 Annotation-based Configuration
 and more…
Other Web Application
Frameworks
 Stripes
 Cocoon
 Echo
 Nacho
 Spring MVC
 JBanana
 WebWork (now Struts 2)
 many others…
What is a Web Application
Framework?
A web application framework is a piece of
structural software that provides automation of
common tasks of the domain as well as a builtin architectural solution that can be easily
inherited by applications implemented on the
framework.
Common Tasks of the
Web Application
 Binding Request Parameters to Java Types
 Validating Data
 Making calls to business logic
 Making calls to the data layer
 Rendering presentation layer (HTML, …)
 Providing internationalization and localization
Struts 2 Project
 Keep Presentation Layer Separate from Data
Layer
Model-View-Controller Architecture
 Model (Struts 2: action)
• Represents the Data Objects
 View (Struts 2: result)
• Screen representation of the Model
 Controller (Struts 2: FilterDispatcher)
• How the user interface reacts to the user’s input
Advantages of MVC
Reliability
High Reuse and Adaptability
Low Development Costs
Rapid Deployment
Maintainability
MVC Architecture Goals
View
Controller
Model
Applying MVC to Web
Applications
View:
 HTML form; native Java interface; client-side
script; applet
Controller:
 Java servlet; session Bean
Model:
 Entity Bean or other business logic object
Interchangeable Elements
View:
 HTML form becomes touch-screen
Controller:
 JSP becomes session bean
Model:
 Entity Bean
MVC and GUIs
Views and Controllers closely interact
(HTML/JSP)
If HTML code is written out entirely through JSP,
the Controller and View (conceptually) merge
A Controller-View pair works with one Model
One Model may have multiple Controller-View
pairs
MVC Advantages
Single point of entry to Model object
Multiple-client support
Design clarity
Modularity
Controlled growth
Portable
Struts 2 and MVC
 To support MVC, struts uses:
 JSPs
 Custom JSP Tags
 Java Servlets
 POJOs for Actions
Struts 2 and MVC
View
request
FilterDispatcher
(Controller)
Struts 2 and MVC
 Controller - FilterDispatcher
 Front Controller pattern
 Maps Requests to Actions
 Servlet Filter that inspects each incoming
request to determine which Struts 2 action
should handle the request.
Struts 2 and MVC
FilterDispatcher
(Controller)
Action 1
Action 2
ActionInvocation
Action 3
Action 4
Struts 2 and MVC
Action 1
Action 2
Models
Action 3
Action 4
Struts 2 and MVC
Action 1
Action 2
ActionInvocation
Action 3
Action 4
Struts 2 and MVC
View
ActionInvocation
Struts 2 and MVC
 The Struts 2 solution to implementing MVC
 View – JSP Page, Velocity, XSLT, RIA, AJAX
 Controller – FilterDispatcher in conjunction
with user-defined Action classes
 Model – Action classes is a locus of data
transfer, a single unit of work that conducts
calls to the business logic
Designing Web
Applications
 High Level Architecture
Presentation
Layer
Control
Layer
Application
Logic
Data
Sources
Architectural Approaches
 Page-centric Design
 Model 1
 Control and application Logic handled by JSP
Servlet-centric Design
 Model 2
 Intermediate servlet ( or servlets ) manage
control and application logic
Page-Centric Design
 Series of interrelated JSP pages
 JSP page
 Perform request processing
 Communicate with back-end data sources
 Generate dynamic content elements
Page-centric Program
Flow
 Role-based Pages
Options.jsp
Query.jsp
Data
Sources
Display.jsp
Simple page-centric
application
 Password.htm
<HTML>
<BODY>
<form action="PasswordGen.jsp" method="POST">
<H3>Welcome to the Password Generator</H3>
First Name: <input type="text" name="firstName"><br>
Last Name: <input type="text" name="lastName"><br>
<p>
<input type="submit" value="Generate Password">
</form>
</BODY>
</HTML>
Simple page-centric
application
 PasswordGen.jsp
Simple page-centric
application
<html>
<body>
<%
String firstName = request.getParameter("firstName");
String lastName = request. getParameter("lastName");
String password;
if( (firstName.length()>=2) && (lastName.length()>=2))
password = lastName.substring(0,2)+firstName.substring(0,2);
else
password = "NoGo";
%>
<h1>
Password Generated!
</h1>
Your super secret password is <%= password %>.
<br><a href="Password.htm">To generate another password.</a>
</body>
</html>
Simple page-centric
application
Page-centric Strategy
 Page-centric approach Benefits
 Very little abstraction
 Few components
 Minimum of layers
 Page-centric approach Limitations
 Maintainability
 Flow Control
Servlet-centric Design
 Servlet handles control and application logic
 Requests are routed to the JSP pages via the
servlet
 Servlet can perform the following:
 Execution of specific business actions on
behalf of a JSP
 Deliver data to a JSP
 Control flow among JSP pages
Command Pattern
 Encapsulate each command our servlet can
handle into its own class
String cmd = req.getParameter(“cmd”);
if (cmd.equals(“buy”)) {
BuyCmd bcmd = new BuyCmd();
bcmd.buy(); }
if (cmd.equals(“sell”)) {
SellCmd scmd = new SellCmd();
scmd.sell(); }
Servlet-centric Program
Flow
Client
Servlet
JSP
Data
Sources
Simple Servlet-centric
application
 Password.htm
<HTML>
<BODY>
<form action="/webapp/passwordservlet" method="POST">
<H3>Welcome to the Password Generator</H3>
First Name: <input type="text" name="firstName"><br>
Last Name: <input type="text" name="lastName"><br>
<p>
<input type="submit" value="Generate Password">
</form>
</BODY>
</HTML>
 passwordServlet.java
Simple Servlet-centric
application
public void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
GenBean gb = new GenBean();
gb.setFirstName(request.getParameter("firstName"));
gb.setLastName(request.getParameter("lastName"));
gb.generate();
request.setAttribute("gen", gb);
RequestDispatcher rd =
getServletContext().getRequestDispatcher("/PasswordGen.j
sp");
rd.forward(request, response);
}
 GenBean.java
public class GenBean {
private String firstName;
private String lastName;
private String password = "NoGo";
Simple Servlet-centric
application
public String getFirstName(){return firstName;}
public void setFirstName(String fn){
firstName = fn;}
public String getLastName(){return lastName;}
public void setLastName(String ln){
lastName = ln;}
public String getPassword(){return password;}
public String generate() {
if( (firstName.length() >= 2) && (lastName.length() >= 2))
password = lastName.substring(0,2) +
firstName.substring(0,2);
return password;
}
}
PasswordGen.jsp
Simple Servlet-centric
application
<html>
<body>
<jsp:useBean id = "gen" class = “genpackage.GenBean"
scope="request"/>
<h1>
Password Generated!
</h1>
Your super secret password is <jsp:getProperty
name="gen" property="password"/>
<br><a href="Password.htm">To generate another
password.</a>
</body>
</html>
Interactive Interfaces
using JSP
 Creating Web-based applications that exhibit
behavior of desktop programs
Must address the stateless nature of Web pages
and Form elements
Sticky Widgets
Validation
Dynamically Generated
HTML
 Use HTML form elements in Web applications
 State is encoded into the HTML typically as value
attributes or the checked keyword
 To maintain state
 Cookies with JavaScript
 Dynamically generated HTML with JSP
• Create a JSP that combines the form and results on
the same page
• Use with Model 1 approach
Sticky Widget Example:
Text Fields
 Text Field state is defined in the value attribute
<input type=“text” name=“desc”
value=“<%= getParam(request, “desc”) %>”>
public String getParam(HttpServletRequest req,
String param) {
if (req.getParameter(param) == null)
return “”;
else
return req.getParameter(param);
}
Sticky Widget Example:
Radio Buttons
 Radio Button state is defined by the checked keyword
<input type=“radio” name=“binary” value=“yes”
<%= isChecked(request,“binary”,“yes”) %>>Yes<br>
<input type=“radio” name=“binary” value=“no”
<%= isChecked(request,“binary”,“no”) %>>No<br>
public String isChecked(HttpServletRequest req, String
param, String testValue) {
return testValue.equals(req.getParameter(param)) ?
“checked” : “”;
}
Validating Form Data
 Client-Side
 Performed with JavaScript
 User is prohibited from submitting form until
validated
 Server-Side
 Request data not guaranteed to come from
browser
 Use JSP sticky widgets to maintain state in
case of input error
 Performance not as good
Form Bean
 More streamlined technique for communicating
the state of form data within a specific request
 Allows for Model 2 approach
public class FormBean {
private String name;
public void setName(String nm) {
name = nm; }
public String getName() { return name; }
…
}
Review
 Introduction to Struts







Model-View-Controller Architecture
Struts and MVC
Architecting Web Applications
Page-centric Design
Servlet-centric Design
JSP Interactive Interfaces
FormBean