jsp architecture outline model 1 architecture model 2 architecture
TRANSCRIPT
JSP Architecture
Outline Model 1 Architecture Model 2 Architecture
Model 1 architecture
JSP-Centric Architecture
– JavaBeans or EJB Model Objects
– View JSP pages
– Action JSP pages
Model 1 architecture
Model 1 architecture
In the Model 1 architecture, the incoming request from a web browser is sent directly to the JSP page, which is responsible for processing it and replying back to the client.
There is still separation of presentation from content, because all data access is performed using beans.
Person Example Program- Navigation Flow
Person Example Program – List Page
Presents a list of Person objects Allows Edit and Create Operations
Person Example Program – Edit Page
• Typical HTML Form Page• Displays Existing Model Object or Empty New Object
Model 1 Architecture - Overview
JSP Components Perform Display and Processing Tasks
Model 1 Architecture – Display Details
• View JSP Pages request model objects from business tier
• Standard JSP Tags used to display data
<jsp:useBean id="person"
class="com.wiley.compBooks.nyberg.ch02.objects.Person" scope="request">
...
person = PersonService.findPersonById(id);
...
</jsp:useBean>
...
<INPUT TYPE="text" NAME="firstName"
value="<jsp:getProperty name="person" property="firstName"/>" size="50"/>
Model 1 Architecture – Form/Submit Details
HTML Form is posted to unique Action JSP page Other techniques include “Self Posting” and “Next-Page
Posting” HTTP Request Parameters extracted using setProperty with *
<jsp:useBean id="person"
class="com.wiley.compBooks.nyberg.ch02.objects.Person" scope="request" />
<jsp:setProperty name="person" property="*" />
Action JSP page performs validation and model updates
Model 1 Architecture – Navigation Details
View JSP Pages hardcode links to other View pages Action JSP Pages hardcode links to destination View pages
// Return to form page if errors are encountered, leaving Person // on requestif (errors.size()>0) { %> <jsp:forward page="EditPerson.jsp" /><%} else { ... redirect(response,"./ShowPeople.jsp"); }
Model 1 Architecture – Summary
Benefits of JSP-Centric Approach
Drawbacks of JSP-Centric Approach
Small number of components required to build a given application
Architecture produces a tightly-coupled application with hard coded page names
Small number of technologies, reducing learning curve for inexperienced resources
Action JSP pages are primarily Java code, but cannot be developed, compiled, and debugged as easily as pure Java code
Re-use of processing and validation logic is hampered by its placement in form-specific action JSP pages
Model 2 architecture
Servlet-Centric Architecture
– JavaBeans or EJB Model Objects
– View JSP pages
– Servlet or Command Classes
Model-View-Controller
Model-View-Controller approach came from SmallTalk community
- Involved notification/event models, direct manipulation of model objects
MVC today is basically a Tiered architecture
- Interposes Controller components between View and Model components
- Controller responsible for navigation, presentation-tier logic, validation
- Emphasizes separation of presentation logic and model objects
Features
Clients do not request pages directly. All clients requests go to a controller servlet. Each request includes data:
The requested action
Any parameters for that action. Controller servlet:
Decides which page should be returned to user.
Augments REQUEST (not response) object with additional data to be
displayed to user.
Advantages
MVC approach simplifies JSP pages:
No navigation code inside them.
No complex data manipulation (db access, etc.)
Clean separation of presentation and processing logic.
The front components present a single point of entry into the application, thus making the management of application state, security, and presentation uniform and easier to maintain.
Multiple views using the same model
Model 2 Architecture
Model 2 Architecture
The processing is divided between presentation (JSPs) and front components (controllers).
Presentation components are JSP pages that generate the HTML/XML response that determines the user interface when rendered by the browser.
Front components do not handle any presentation issues, but rather, process all the HTTP requests. They are responsible for creating any beans or objects used by the presentation components, as well as deciding, depending on the user's actions, which presentation component to forward the request to.
Front components can be implemented as either a servlet or JSP page.
Model 2 Architecture Issues
Single or Multiple controller servlets Different views to be supported Single functionality in page
Controller Responsibilities
Request processing Creation of any beans or objects used by the
presentation JSP Deciding, depending on the user's actions, which
JSP to forward the request to. Data validation
Controller Design
Poorly designed controller
if (op.equals("createUser"))
{
model.createUser(request.getAttribute("user"), request.getAttribute("pass"));
}
else if (op.equals("changeUserInfo")
{
// ... and so on...
}
Controller Design
Controller using Command Pattern
public abstract class Action
{
protected Model model;
public Action(Model model) { this.model = model; } public abstract String getName();
public abstract Object perform(HttpServletRequest req);
}
Controller Design
public class CreateUserAction extends Action
{
public CreateUserAction(Model model) { super(model);}
public String getName() { return "createUser"; }
public Object perform(HttpServletRequest req)
{
return model.createUser(req.getAttribute("user"), req.getAttribute("pass"));
}
}
Controller Design
public class ControllerServlet extends HttpServlet {
private HashMap actions;
public void init() throws ServletException {
actions = new HashMap();
CreateUserAction cua = new CreateUserAction(model);
actions.put(cua.getName(), cua);
}
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
Controller Design
String op = getOperation(req.getRequestURL());
Action action = (Action)actions.get(op);
Object result = null;
try {
result = action.perform(req);
} catch (NullPointerException npx) {
}
}
View Responsibilities
There is no processing logic within the presentation JSP itself: it is simply responsible for retrieving any objects or beans that may have been previously created by the Servlet, and extracting the dynamic content for insertion within static templates.
Sample View
<H1>Best Available Flights</H1>
<jsp:useBean id="customer"
class="moreservlets.TravelCustomer"
scope="session" />
Finding flights for
<jsp:getProperty name="customer" property="fullName" />
<P>
<jsp:getProperty name="customer" property="flights" />
<P><BR><HR><BR>
<jsp:getProperty name="customer"
property="frequentFlyerTable" />
Tag Libraries and M2
Client
Controller
Action
JSP Page
Dispatch
forward
Server side objects
Tag libraries and business objects
JSP pageinclude