Design Your Own MVC Framework

The fact is that I recently read the J2EE design patterns chapter on the expression layer patterns. There is a front-end controller + command mode workflow example in the book, I thought it would be easy to expand into an MVC framework. It took me an afternoon to rewrite the document and give a deeper understanding of the book. I think this may be helpful for people who learn and understand the design pattern and who first came into contact with Struts and other MVC frameworks. Because the entire model is similar to struts, I name it strutslet into _^. Learning nature. Do not take it seriously.

(1) The complete class diagram is as follows:

1. Frontcontroller: the front-end Controller provides a unified location for encapsulating public request processing. The task is quite simple. It executes public tasks and then forwards the requests to the corresponding controller. In strutslet, the front-end controller is also used to initialize and parse the configuration file, accept each request, and simply delegate the request to the scheduler (dispatcher ), the scheduler executes the corresponding action ). The scheduler returns the URL returned by the action to frontcontroller, which is responsible for forwarding.

2. Action interface: a good example of the command mode. It is a command interface. Every action that implements this interface encapsulates a request: Add a data record and update the model, or write a file to the disk. The command decouples the contact between the sender and the receiver. The sender calls an operation and the receiver accepts the request to execute the corresponding action. Because the command mode is used for decoupling, the sender does not need to know the receiver's interface.

3. Dispatcher: scheduler, responsible for process forwarding and calling action to execute business logic. The scheduler selects the page and action to remove the coupling between the application behavior and the front-end controller. The scheduler serves the front-end controller. It delegates model updates to action and provides the page selection to frontcontroller.

4. Actionforward: a model that encapsulates the information required for a redirection operation, including name and Redirection URL.

5. Actionmodel: after parsing the configuration file, each action is encapsulated into an actionmodel object. All actionmodels constitute a map and are stored in servletcontext for the entire framework.

(2) simple source code analysis
1. Action interface. There is only one execute method. Any action only needs to implement this interface and implement the corresponding business logic. Finally, an actionforward is returned for dispacher to call.

2. Public InterfaceAction {
3.  PublicActionforward execute (httpservletrequest request, servletcontext context );
4. }

For example, to implement a login System (Demo example), loginaction verifies the username and password. If the username and password are correct, the success page is returned. If the login fails, the Fail page is returned:

2. Public ClassLoginactionImplementsAction {
4.  Private StringName = "";
5.  PublicActionforward execute (httpservletrequest request,
6. Servletcontext context ){
7. StringUsername = request. getparameter ("username ");
8. StringPassword = request. getparameter ("password ");
9. If(Username. Equals ("Dennis") & password. Equals ("123 ")){
10. Request. setattribute ("name", name );
11. ReturnActionforward. success;// If the logon succeeds, success is returned.
12. }Else
13. ReturnActionforward. fail;// Otherwise, return fail
14. }

2. Let's take a look at two models: actionforward and actionmodel. There is nothing, attributes, and the corresponding getter and setter methods:

2. /**
3. * Class description: Steering Model
4. * @ Author Dennis
5. *
6. **/
7. Public ClassActionforward {
8.  Private StringName;// Forward name
9.  Private StringViewurl;// Forward URL
10.  Public Static FinalActionforward success =NewActionforward ("success ");
11.  Public Static FinalActionforward fail =NewActionforward ("fail ");
13.  PublicActionforward (StringName ){
14. This. Name = Name;
15. }
17.  PublicActionforward (StringName,StringViewurl ){
18. Super();
19. This. Name = Name;
20. This. Viewurl = viewurl;
21. }
23.  // Getter and setter methods of... Name and viewurl
25. }

We can see that actionforward encapsulates success and fail objects in advance.

2. Public ClassActionmodel {
3.  Private StringPath;// Action path
5.  Private StringClassname;// Action class
7.  PrivateMap <String, Actionforward> forwards;// Action forward
9.  PublicActionmodel (){}
11.  PublicActionmodel (StringPath,StringClassname,
12. Map <String, Actionforward> forwards ){
13. Super();
14. This. Path = path;
15. This. Classname = classname;
16. This. Forwards = forwards;
17. }
20.  //... Corresponding getter and setter Methods
22. }

3. Knowing what the two models are, we should be able to guess what our configuration file is like, similar to the struts configuration file format:

2. <? XML version = "1.0" encoding = "UTF-8"?>
3. <Actions>
4. <Action Path = "/login"
5. Class= "Com. strutslet. Demo. loginaction">
6. <Forward name = "success" url = "Hello. jsp"/>
7. <Forward name = "fail" url = "fail. jsp"/>
8. </Action>
9. </Actions>

The path is the path to be called in the application. The class specifies the action to be called, and the forward element specifies the redirection. For example, if success is used, we will switch to hello. JSP. If it fails, it turns to fail. JSP. The loginaction used in the demo is configured here.

4. The dispacher interface is mainly the getnextpage method, which is used to obtain the next page direction and forward it to the front-end controller.

2. Public InterfaceDispatcher {
3.  Public VoidSetservletcontext (servletcontext context );
4.  Public StringGetnextpage (httpservletrequest request, servletcontext context );
5. }

5. 5. In the original book, a workflow dispatcher is implemented to call the action in order to call the workflow. What we need is to call the corresponding action according to the Request Path, execute the action execute method to return an actionforward, then get the viewurl of actionforward, and provide this viewurl to the front-end controller for forwarding, let's take a look at its getnextpage method:

2. Public StringGetnextpage (httpservletrequest request, servletcontext context ){
3. Setservletcontext (context );
5. Map <String, Actionmodel> actions = (Map <String, Actionmodel>) Context
6. . Getattribute (constant. actions_attr );// Obtain all action information from servletcontext
7. StringReqpath = (String) Request. getattribute (constant. request_attr );// The Request Path
8. Actionmodel = actions. Get (reqpath );// Obtain the corresponding action based on the path.
9. StringForward_name = "";
10. Actionforward;
11. Try{
12. ClassC =Class. Forname (actionmodel. getclassname ());// Each request corresponds to an action instance
14. Action action = (Action) C. newinstance ();
15. Actionforward = action.exe cute (request, context );// Execute Method for executing action
16. Forward_name = actionforward. getname ();
18. }Catch(ExceptionE ){
19. Log. Error ("can not find action" + actionmodel. getclassname ());
20. E. printstacktrace ();
21. }
23. Actionforward = actionmodel. getforwards (). Get (forward_name );
24. If(Actionforward =Null){
25. Log. Error ("can not find page for forward" + forward_name );
26. Return Null;
27. }Else
28. ReturnActionforward. getviewurl ();// Return the viewurl of actionforward
29. }

6. Front-end controller (frontcontroller), whose tasks are clear, initialize the configuration file, store all actions to the servletcontext for use by the entire framework, and obtain the Request Path, call dispatcher and run the getnextpage method to get the URL of the next page:

2. Public VoidInit ()ThrowsServletexception {
4. // Initialize the configuration file
6. Servletcontext context = getservletcontext ();
7. StringConfig_file = getservletconfig (). getinitparameter ("Config ");
8. StringDispatcher_name = getservletconfig (). getinitparameter ("dispatcher ");
9. If(Config_file =Null| Config_file.equals (""))
10. Config_file = "/WEB-INF/strutslet-config.xml ";// The default is/WEB-INF/strutslet-config below
11. If(Dispatcher_name =Null| Dispatcher_name.equals (""))
12. Dispatcher_name = constant. default_dispatcher;
14. Try{
15. Map <String, Actionmodel> resources = configutil. newinstance ()// Tool-class parsing configuration file
16. . Parse (config_file, context );
17. Context. setattribute (constant. actions_attr, resources );// Stored in servletcontext
18. Log.info ("The strutslet configuration file has been initialized successfully ");
19. }Catch(ExceptionE ){
20. Log. Error ("failed to initialize the strutslet configuration file ");
21. E. printstacktrace ();
22. }
24. // Instantiate dispacher
26. Try{
27. ClassC =Class. Forname (dispatcher_name );
28. Dispatcher dispatcher = (dispatcher) C. newinstance ();
29. Context. setattribute (constant. dispatcher_attr, dispatcher );// Put it in servletcontext
30. Log.info ("dispatcher initialization succeeded ");
31. }Catch(ExceptionE ){
32. Log. Error ("dispatcher initialization failed ");
33. E. printstacktrace ();
34. }
36. .....

The doget () and dopost Methods let it call the process method:

2. Protected VoidProcess (httpservletrequest request,
3. Httpservletresponse response)ThrowsServletexception, ioexception {
4. Servletcontext context = getservletcontext ();
6. // Obtain the action path
7. StringRequri = request. getrequesturi ();
8. IntI = requri. lastindexof (".");
9. StringContextpath = request. getcontextpath ();
10. StringPath = requri. substring (contextpath.Length(), I );
12. Request. setattribute (constant. request_attr, PATH );
13. Dispatcher dispatcher = (dispatcher) Context. getattribute (constant. dispatcher_attr );
15. // Make sure we don't cache dynamic data
16. Response. setheader ("cache-control", "No-Cache ");
17. Response. setheader ("Pragma", "No-Cache ");
19. // Use the dispatcher to find the next page
20. StringNextpage = dispatcher. getnextpage (request, context );// Call the getnextpage of dispatcher.
22. // Forward control to the view
23. Requestdispatcher forwarder = request. getrequestdispatcher ("/"
24. + Nextpage );
25. Forwarder. Forward (request, response );// Forwarding page
26. }

7. Finally, Web. xml configuration is very simple, configure the front-end controller, provide startup parameters (configuration file location, empty search/WEB-INF/below the strutslet-config.xml file ), we send all requests ending with an action to frontcontroller for processing:

2. <Servlet>
3. <Servlet-Name> strutsletcontroller </servlet-Name>
4. <Servlet-Class> Com. strutslet. Core. frontcontroller </servlet-Class>
5. <! --
6. <Init-param>
7. <Param-Name> config </param-Name>
8. <Param-value>/WEB-INFstrutslet-config.xml </param-value>
9. </Init-param>
10. -->
11. <Load-on-startup> 0 </load-on-startup>
12. </Servlet>
13. <Servlet-mapping>
14. <Servlet-Name> strutsletcontroller </servlet-Name>
15. <URL-pattern> *. Action </url-pattern>
16. </Servlet-mapping>

Finally, let's look at the entire framework: