MVC (Model View Controller) draait juist om het feit dat je presentatie (jsp) en logica (Model) van elkaar scheidt. Hierbij draait alles om de combinatie van de controller (servlet), een action Interface, een Map (HashMap) en uiteindelijk de action classes die de action interface implementeren.
Onder de motorkap gebeurt dan het volgende:
request (in querystring action=foobar > servlet > match action ("foobar" met een entry "foobar" in de Map > voor de action uit (databse query's etc) > forward naar jsp. In feite voert de controller alle operaties uit.
Voorbeeld:
De Controller (servlet)
Java:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| public class Controller extends HttpServlet {
private static final String CONTENT_TYPE = "text/html";
private ActionMapping mapping;
private HttpServletRequest request;
private HttpServletResponse response;
public void init() throws ServletException {
mapping = new ActionMapping();
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.request = request;
this.response = response;
Action a = mapping.findAction(getActionName()); // hier de corresponderende class instantieren (getActioName haalt de action uit de querystring)
String path = a.perform(request, response); // methode perform uitvoeren (omdat alle *Action classes de interface implementeren, weet je dat ze allemaal deze methode MOETEN bevatten!)
forward(path); // forwarden naar view (jsp)
}
protected String getActionName(){
String action = request.getParameter("action");
if ((action==null) || (action.equals(""))) action="Index";
return action;
}
protected void forward(String path)
throws ServletException, IOException {
RequestDispatcher disp = request.getRequestDispatcher(path);
disp.forward(request, response);
}
//Clean up resources
public void destroy() {
}
} |
De Action Interface:
Java:
1
2
3
4
5
6
| public interface Action {
public String perform(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException;
} |
De ActionMapper:
Java:
1
2
3
4
5
6
7
8
9
10
11
12
| public class ActionMapping {
private HashMap actionMap;
public ActionMapping() {
actionMap = new HashMap();
actionMap.put("foobar", new FoobarAction());
}
public Action findAction(String actionName){
return (Action) actionMap.get(actionName);
}
} |
En dan zien de logica classes er ongeveer als volgt uit:
Java:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class FoobarAction implements Action {
public FoobarAction () {
}
public String perform(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Eventuele variabelen ophalen uit querystring of form
// Query's uitvoeren
request.setAttribute("resultaat", "De informatie die getoond moet worden komt hier (bijv array)"); // in jsp vervolgens request.getAttribute("resultaat") om de info weer te geven (of door een meegestuurde array te ittereren oid)
return "foobar.jsp"; // methode forward() in de controller forward naar deze pagina
}
} |
Ik hoop dat je hier wat wijzer van wordt. Dit heb ik het vaak gebruikt als het om een "lichgewicht" mvc implementatie ging.
Als je het gaat gebruiken, hou er dan wel even rekening mee dat de packages en imports gemakshalve zijn weggelaten.
De werking is honderd procent gegarandeert en het is een heuze implementatie van het MVC design pattern.
p.s. sorry voor het ontbreken van commentaar in de code, maar daar ben ik nu even te lui voor
:strip_exif()/u/13818/episodebutler_60x60.gif?f=community)
:strip_icc():strip_exif()/u/32734/crop5ee11f3ba965d_cropped.jpeg?f=community)