Using the MVC design pattern with JSP/Servlet
The core (architectural) design pattern you'd like to use is the
Model-View-Controller pattern. The
Controller is to be represented by a Servlet which (in)directly creates/uses a specific
Model and
View based on the request. The
Model is to be represented by Javabean classes. This is often further dividable in
Business Model which contains the actions (behaviour) and
Data Model which contains the data (information). The
View is to be represented by JSP files which have direct access to the (
Data)
Model by EL (Expression Language).
Then there are variations based on how actions and events are handled. The popular ones are:
- Request (action) based MVC: this is the simplest to implement. The (Business) Model works directly with
HttpServletRequest and HttpServletResponse objects. You have to gather, convert and validate the request parameters (mostly) yourself. The View can be represented by plain vanilla HTML/CSS/JS and it does not maintain state across requests. This is how among others Spring MVC, Struts and Stripes works.
- Component based MVC: this is harder to
implement. But you end up with a simpler model and view wherein all the
"raw" Servlet API is abstracted completely away. You shouldn't have the
need to gather, convert and validate the request parameters yourself.
The Controller does this task and sets the gathered, converted and validated request parameters in the Model. All you need to do is to define action methods which works directly with the model properties. The View is represented by "components" in flavor of JSP taglibs or XML elements which in turn generates HTML/CSS/JS. The state of the View
for the subsequent requests is maintained in the session. This is
particularly helpful for server-side conversion, validation and value
change events. This is how among others JSF, Wicket and Play! works.
As a side note, I warmly recommend to pick an existing framework
rather than reinventing your own. Learning an existing and
well-developed framework takes in long term less time than developing
and maintaining a robust framework yourself. From the mentioned ones I
personally recommend
JSF 2.0.
In the below detailed explanation I'll restrict myself to request based MVC since that's easier to implement.
First, the
Controller part should implement the
Front Controller pattern (which is a specialized kind of
Mediator pattern). It should exist of only a single servlet which provides a centralized entry point of all requests. It should create the
Model based on information available by the request, such as the pathinfo or servletpath, the method and/or specific parameters. The
Business Model is called
Action in the below
HttpServlet example.
protected void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
try {
Action action = ActionFactory.getAction(request);
String view = action.execute(request, response);
if (view.equals(request.getPathInfo().substring(1)) {
request.getRequestDispatcher("/WEB-INF/" + view + ".jsp")
.forward(request, response);
} else {
response.sendRedirect(view);
// We'd like to fire redirect in case of a view change as
//result of the action (PRG pattern).
}
} catch (Exception e) {
throw new ServletException("Executing action failed.", e);
}
}
The
Action should follow the
Stategy pattern. It needs to be definied as an abstract/interface type which should do the work based on the
passed-in arguments of the abstract method (this is the difference with the
Command pattern, wherein the abstract/interface type should do the work based on the arguments which are been passed-in during the
creation of the implementation).
public interface Action {
public String execute(HttpServletRequest request, HttpServletResponse response) throws Exception;
}
You may want to make the
Exception more specific with a custom exception like
ActionException. It's just a basic kickoff example, the remnant is all up to you.
Here's an example of a
LoginAction which (as its name says) logs in the user. The
User itself is in turn a
Data Model. The
View is aware of the presence of the
User.
public class LoginAction implements Action {
public String execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
String username = request.getParameter("username");
String password = request.getParameter("password");
User user = userDAO.find(username, password);
if (user != null) {
request.getSession().setAttribute("user", user); // Login user.
return "home"; // Redirect to home page.
} else {
request.setAttribute("error", "Unknown username/password. Please retry."); // Store error message in request scope.
return "login"; // Go back to redisplay login form with error.
}
}
}
The
ActionFactory should follow the
Abstract Factory pattern.
Basically, it should provide a creational method which returns an
abstract/interface type. In this case, it should return an
implementation of the
Action interface based on the information provided by the request. For example, the
method and
pathinfo (the pathinfo is the part after the context and servlet path in the request URL, excluding the query stirng).
public static Action getAction(HttpServletRequest request) {
return actions.get(request.getMethod() + request.getPathInfo());
}
The
actions in turn should be some static/applicationwide
Map<String, Action> which holds all known actions. It's up to you how to fill this map. Hardcoding:
actions.put("POST/register", new RegisterAction());
actions.put("POST/login", new LoginAction());
actions.put("GET/logout", new LogoutAction());
// ...
Or configureable based on a properties/XML configuration file in the classpath: (pseudo)
for (Entry entry : configuration) {
actions.put(entry.getKey(), Class.forName(entry.getValue()).newInstance());
}
Or dynamically based on a scan in the classpath for classes implementing a certain interface and/or annotation: (pseudo)
for (ClassFile classFile : classpath) {
if (classFile.isInstanceOf(Action.class)) {
actions.put(classFile.getAnnotation("mapping"), classFile.newInstance());
}
}
Keep in mind to create a "do nothing"
Action for the case there's no mapping. Let it for example return directly the
request.getPathInfo().substring(1) then.
Abstract factory (recognizeable by creational methods returning an abstract/interface type)
Builder (recognizeable by creational methods returning the instance itself)
Factory method (recognizeable by creational methods returning a concrete type)
Prototype (recognizeable by creational methods returning a different instance of itself with the same properties)
Singleton (recognizeable by creational methods returning the same instance (usually of itself) everytime)
Adapter (recognizeable by creational methods taking an instance of different abstract/interface type and returning an implementation of own/another abstract/interface type which decorates/overrides the given instance)
Bridge (recognizeable by creational methods taking an instance of different abstract/interface type and returning an implementation of own abstract/interface type which delegates/uses the given instance)
- None comes to mind yet. A fictive example would be
new LinkedHashMap(LinkedHashSet<K>, List<V>) which returns an unmodifiable linked map which doesn't clone the items, but uses them. The java.util.Collections#newSetFromMap() and singletonXXX() methods however comes close.
Composite (recognizeable by behavioral methods taking an instance of same abstract/interface type)
Decorator (recognizeable by creational methods taking an instance of same abstract/interface type)
Facade (recognizeable by behavioral methods which internally uses instances of different independent abstract/interface types)
Flyweight (recognizeable by creational methods returning a cached instance, a bit the "multiton" idea)
Proxy (recognizeable by creational methods which returns an implementation of given abstract/interface type which in turn delegates/uses a different implementation of given abstract/interface type)
Chain of responsibility (recognizeable by behavioral methods which (indirectly) invokes the same method in another implementation of same abstract/interface type in a queue)
Command (recognizeable by behavioral methods in an abstract/interface type which invokes a method in an implementation of a different abstract/interface type which has been encapsulated by the command implementation during its creation)
Interpreter (recognizeable by behavioral methods returning a structurally
different instance/type of the given instance/type; note that
parsing/formatting is not part of the pattern, determining the pattern
and how to apply it is)
Iterator (recognizeable by behavioral methods sequentially returning instances of a different type from a queue)
Mediator (recognizeable
by behavioral methods taking an instance of different
abstract/interface type (usually using the command pattern) which
delegates/uses the given instance)
Memento (recognizeable by behavioral methods which internally changes the state of the whole instance)
Observer (or Publish/Subscribe) (recognizeable by behavioral methods which invokes a method on an instance of another abstract/interface type, depending on own state)
State (recognizeable
by behavioral methods which changes its behaviour depending on the
instance's state which can be controlled externally)
Strategy (recognizeable by behavioral methods in an abstract/interface type which invokes a method in an implementation of a different abstract/interface type which has been passed-in as method argument into the strategy implementation)
Template method (recognizeable by behavioral methods which already have a "default" behaviour definied by an abstract type)
Visitor (recognizeable by two different abstract/interface types which has methods definied which takes each the other abstract/interface type; the one actually calls the method of the other and the other executes the desired strategy on it)
