【SSH进阶之路】一步步重构MVC实现Struts框架——彻底去掉逻辑判断（五）

目录：

      【SSH进阶之路】Struts基本原理 + 实现简单登录（二）

      【SSH进阶之路】一步步重构MVC实现Struts框架——从一个简单MVC开始（三）

      【SSH进阶之路】一步步重构MVC实现Struts框架——封装业务逻辑和跳转路径（四）

      【SSH进阶之路】一步步重构MVC实现Struts框架——彻底去掉逻辑判断（五）

      【SSH进阶之路】一步步重构MVC实现Struts框架——完善转向页面，大功告成（六）

 

      Struts的第二篇博客【SSH进阶之路】Struts基本原理 + 实现简单登录（二），我们介绍了MVC模型和Struts的基本理论，对比学习了他们之间的联系和区别。从第三篇博客【SSH进阶之路】一步步重构MVC实现Struts框架——从一个简单MVC开始（三）开始，我们实现了一个简单MVC模型，提出了三个重构的问题。

       上篇博客【SSH进阶之路】一步步重构MVC实现Struts框架——封装业务逻辑和跳转路径（四），我们解决了第一个问题：封装业务逻辑和跳转路径。这篇博客我们解决第二个问题：彻底去掉Servlet中的逻辑判断。

我们先回顾一下上篇博客中的TestServlet的代码：

[java] view plain copy

 print?

1. package com.liang.servlet;  
2.   
3. import java.io.IOException;  
4. import javax.servlet.ServletException;  
5. import javax.servlet.http.HttpServlet;  
6. import javax.servlet.http.HttpServletRequest;  
7. import javax.servlet.http.HttpServletResponse;  
8.   
9. import com.liang.action.Action;  
10. import com.liang.action.AddUserAction;  
11. import com.liang.action.DelUserAction;  
12. import com.liang.action.ModifyUserAction;  
13. import com.liang.action.QueryUserAction;  
14. /** 
15.  * 使用servlet做相关的控制，转向多个（V）视图 
16.  * @author liang 
17.  * 
18.  */  
19. public class TestServlet extends HttpServlet {  
20.   
21.     @Override  
22.     protected void doGet(HttpServletRequest request, HttpServletResponse response)  
23.             throws ServletException, IOException {  
24.         //取得访问的URI  
25.         String reqeuestURI = request.getRequestURI();  
26.         System.out.println(reqeuestURI);  
27.         //截取URI，获得路径  
28.         String path = reqeuestURI.substring(reqeuestURI.indexOf("/",1), reqeuestURI.indexOf("."));  
29.         System.out.println(path);  
30.           
31.         Action action = null;  
32.         //等于添加，调用AddUserAction  
33.         if ("/servlet/addUser".equals(path)) {  
34.             action = new AddUserAction();  
35.         //等于删除，调用DelUserAction  
36.         }else if ("/servlet/delUser".equals(path)) {  
37.             action = new DelUserAction();  
38.         //等于修改，调用ModifyUserAction  
39.         }else if ("/servlet/modifyUser".equals(path)) {  
40.             action = new ModifyUserAction();  
41.         //等于查询，调用QueryUserAction  
42.         }else if ("/servlet/queryUser".equals(path)) {  
43.             action = new QueryUserAction();  
44.         }else {  
45.             throw new RuntimeException("请求失败");  
46.         }  
47.         String forward = null;  
48.         //返回不同的转向页面  
49.         try {  
50.             forward = action.execute(request, response);  
51.         } catch (Exception e) {  
52.             e.printStackTrace();  
53.         }  
54.         //根据路径,统一完成转向  
55.         request.getRequestDispatcher(forward).forward(request, response);  
56.     }  
57.   
58.     @Override  
59.     protected void doPost(HttpServletRequest request, HttpServletResponse response)  
60.             throws ServletException, IOException {  
61.         doGet(request,response);  
62.     }  
63.   
64. }  

 

      我们来分析一下上面TestServlet中的代码，我们发现了多个逻辑判断IF..ELSE，系统不灵活，需求改变时，违背了开发封闭原则，不能满足需求。我们知道我们配置连接数据库信息时，使数据库更加灵活，使用了配置文件。

      下面我们也打算把所有的字符串和业务逻辑的实现类都配置到配置文件中，最后通过实现类的方法来返回跳转路径，最终跳转到相应的页面。 需求改变时，修改配置文件即可。

      所以配置文件不仅要配上Servlet中出现的字符串，还要配置相应的Action接口的实现类（我们可以利用反射来动态的实例化该类的对象，进而使用多态的机制动态这个类的所有属性和方法），另外返回跳转路径字符串。其实此时和Struts的配置文件的道理是一致，我们也只需要自己实现一个配置文件。

web.xml，我们将struts-config.xml配置成tomacat启动时就初始化

[html] view plain copy

 print?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5"   
3.     xmlns="http://java.sun.com/xml/ns/javaee"   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
6.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
7.   <welcome-file-list>  
8.     <welcome-file>index.jsp</welcome-file>  
9.   </welcome-file-list>  
10.   <!-- 配置TestServlet类 -->  
11.   <servlet>  
12.         <servlet-name>TestServlet</servlet-name>  
13.         <!-- 配置成自己写的TestServlet的路径 -->  
14.         <servlet-class>com.liang.servlet.TestServlet</servlet-class>  
15.         <!-- tomacat启动时，初始化struts-config.xml的配置 -->  
16.         <init-param>  
17.             <param-name>config</param-name>  
18.             <param-value>/WEB-INF/struts-config.xml</param-value>  
19.         </init-param>  
20.         <load-on-startup>0</load-on-startup>  
21.     </servlet>  
22.   
23.   <!-- 怎么访问与jsp的action的路径一致 -->  
24.   <servlet-mapping>  
25.     <servlet-name>TestServlet</servlet-name>  
26.     <!-- 只要是.do请求都会到达servlet -->  
27.     <url-pattern>*.do</url-pattern>  
28.   </servlet-mapping>  
29.     
30. </web-app>  

com.liang.servlet.TestServlet，就是我们的核心Servlet。

struts-config.xml，将path路径和Action的实现类，配置成map结构

[html] view plain copy

 print?

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3. <action-config>  
4.     <action-mappings>  
5.         <!--根据不同的path路径，访问各自的Action  -->  
6.         <action path="/servlet/delUser" type="com.liang.action.DelUserAction"></action>  
7.         <action path="/servlet/addUser" type="com.liang.action.AddUserAction"></action>  
8.         <action path="/servlet/modifyUser" type="com.liang.action.ModifyUserAction"></action>  
9.         <action path="/servlet/queryUser" type="com.liang.action.QueryUserAction"></action>  
10.     </action-mappings>  
11. </action-config>  

      下面我们只需要读取配置文件，实现相应的功能。读取xml，非常流行的一种方式就是使用dom4j，我们曾经也实现过了dom4j读取xml的例子，但是使用dom4j读取配置文件之后，我们需要将信息放置到哪，毋庸置疑，我们需要一个map结构的类，用于存放路径信息和action实现类（type）的信息，里面最少需要两个参数，如下：

 

ActionMapping

[java] view plain copy

 print?

1. package com.liang.action;  
2.   
3. public class ActionMapping {  
4.   
5.     //路径信息  
6.     private String path;  
7.     //action实现类信息  
8.     private String type;  
9.     public String getType() {  
10.         return type;  
11.     }  
12.     public void setType(String type) {  
13.         this.type = type;  
14.     }  
15.     public String getPath() {  
16.         return path;  
17.     }  
18.     public void setPath(String path) {  
19.         this.path = path;  
20.     }  
21.   
22. }  

      配置信息，我们已经放到了一个map中，此时一个请求过来，我们需要跟上面TestServlet中的IF语句一样，根据截取的URL请求，到Map中取得本次请求对应的Action拿出来，但是Action有多个， 我们还需要一个map结构，用来区分此时的URL请求对应哪一个Action。所以此时我们还需要一个存储Action的map结构。（如果没有看懂，没事，下面的代码中有注释，可以帮助你）

 

Mappings

[java] view plain copy

 print?

1. package com.liang.action;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. public class Mappings {  
7.     public static Map actions = new HashMap();    
8. }  

此时，我们的准备工作已经做完了，我们需要使用dom4j读取配置文件，存储到相应的map结构中。

ConfigInit

struts-config.xml解析器。把解析后的结点保存到ActionMapping里，MappingAction是我们上面封装的一个类。如何解析看代码：

[java] view plain copy

 print?

1. package com.liang.servlet;  
2.   
3. import java.io.File;  
4. import java.util.Iterator;  
5.   
6. import org.dom4j.Document;  
7. import org.dom4j.Element;  
8. import org.dom4j.io.SAXReader;  
9.   
10. import com.liang.action.*;  
11.   
12. public class ConfigInit {  
13.   
14.     public static void init(String config) {  
15.         // 创建saxReader对象  
16.         SAXReader reader = new SAXReader();  
17.         File f = new File(config);  
18.         try {  
19.             // 通过read方法读取xml文件， 转换成Document对象  
20.             Document doc = reader.read(f);  
21.             // 得到配置文件的根结点  
22.             Element root = doc.getRootElement();  
23.             Element actionmappings = (Element) root.element("action-mappings");  
24.             // 解析action结点的所有参数  
25.             for (Iterator j = actionmappings.elementIterator("action"); j  
26.                     .hasNext();) {  
27.                 Element am = (Element) j.next();  
28.                 ActionMapping actionMapping = new ActionMapping();  
29.   
30.                 // 设置actionMapping的path和type  
31.                 actionMapping.setPath(am.attributeValue("path"));  
32.                 actionMapping.setType(am.attributeValue("type"));  
33.                 /* 
34.                  * 下面Mappings.actions的存储结构相当于将配置文件struts-config.xml与映射一一对应 
35.                  * map.put("/servlet/delUser", actionMapping); 
36.                  * map.put("/servlet/addUser", actionMapping); 
37.                  * map.put("/servlet/modifyUser", actionMapping); 
38.                  * map.put("/servlet/queryUser", actionMapping); 
39.                  */  
40.                 Mappings.actions.put((String) am.attributeValue("path"),  
41.                         actionMapping);  
42.                   
43.             }  
44.         } catch (Exception e) {  
45.             e.printStackTrace();  
46.         }  
47.     }  
48. }  

最后，万事具备就差东风了，我们看一下最关键的类TestServlet。

      其实它就是普通的Servlet。通过上面web.xml的映射，只要是.do的访问都会先能过这个Servlet过滤到想要访问的Action里。因为这个Servlet的load-on-startup设置为０，所以Tomcat启动时，会执行init方法。ConfigInit类就是我的struts-config.xml解析器。

TestServlet

[java] view plain copy

 print?

1. package com.liang.servlet;  
2.   
3. import java.io.IOException;  
4.   
5. import javax.servlet.ServletException;  
6. import javax.servlet.http.HttpServlet;  
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletResponse;  
9. import com.liang.action.Action;  
10. import com.liang.action.ActionMapping;  
11. import com.liang.action.Mappings;  
12.   
13. /** 
14.  * 使用servlet做相关的控制，转向多个（V）视图 
15.  * @author liang 
16.  * 
17.  */  
18. public class TestServlet extends HttpServlet {  
19.   
20.     //需要读取的文件名  
21.     protected static String config = "/WEB-INF/struts-config.xml";  
22.   
23.     public void init() throws ServletException {  
24.         //获得文件的路径  
25.         //initialize();  
26.         //根据web.xml中映射的目录获得文件在对应服务器中的真实路径  
27.         config = getServletContext().getRealPath("/")+ getInitParameter("config");  
28.         //解析struts-config.xml配置文件  
29.         ConfigInit.init(config);  
30.     }  
31.   
32.     //根据web.xml中映射的目录获得文件在对应服务器中的真实路径  
33. //  private void initialize() {  
34. //      try {  
35. //          config = getServletContext().getRealPath("/")  
36. //                  + getInitParameter("config");  
37. //      } catch (Exception e) {  
38. //          e.printStackTrace();  
39. //      }  
40. //  }  
41.     @Override  
42.     protected void doGet(HttpServletRequest request, HttpServletResponse response)  
43.             throws ServletException, IOException {  
44.           
45.         //取得访问的URI  
46.         String reqeuestURI = request.getRequestURI();  
47.         //截取URI，获得路径  
48.         String path = reqeuestURI.substring(reqeuestURI.indexOf("/",1), reqeuestURI.indexOf("."));  
49.           
50.         Mappings mapings = new Mappings();  
51.         // 根据截取的URL请求，到Map中取得本次请求对应的Action类  
52.         ActionMapping actionMapping = (ActionMapping)mapings.actions.get(path);    
53.         //取得本请求对应的Action类的完整路径  
54.         String type = actionMapping.getType(); //com.liang.action.DelUserAction  
55.         //采用反射，动态实例化Action  
56.         try {  
57.             Action action = (Action)Class.forName(type).newInstance();  
58.             // 采用多态的机制，动态调用Action中的execute方法，返回转向路径  
59.             String forward = action.execute(request, response);  
60.               
61.             //根据转向路径完成转向  
62.             request.getRequestDispatcher(forward).forward(request, response);  
63.         } catch (InstantiationException e) {  
64.             e.printStackTrace();  
65.         } catch (IllegalAccessException e) {  
66.             e.printStackTrace();  
67.         } catch (ClassNotFoundException e) {  
68.             e.printStackTrace();  
69.         } catch (Exception e) {  
70.             e.printStackTrace();  
71.         }  
72.              
73.     }  
74.   
75.     @Override  
76.     protected void doPost(HttpServletRequest request, HttpServletResponse response)  
77.             throws ServletException, IOException {  
78.         doGet(request,response);  
79.     }  
80.   
81. }  

Action实现类的代码，我只贴一个添加用户的，其他类都没有改变，代码就不再重复了。

 

AddUserAction

[java] view plain copy

 print?

1. package com.liang.action;  
2.   
3. import javax.servlet.http.HttpServletRequest;  
4. import javax.servlet.http.HttpServletResponse;  
5.   
6. import com.liang.servlet.UserManager;  
7.   
8. public class AddUserAction implements Action {  
9.   
10.     @Override  
11.     public String execute(HttpServletRequest req, HttpServletResponse resp)  
12.             throws Exception {  
13.         //获取参数  
14.         String username = req.getParameter("username");  
15.           
16.         UserManager userManager = new UserManager();  
17.         //调用业务逻辑  
18.         userManager.add(username);  
19.         //返回跳转页面  
20.         return "/add_success.jsp";//转向路径可以通过配置文件读取  
21.     }  
22. }  

      现在我们发现TestServlet中所有的IF...ELSE语句都消失了，而且没有了业务逻辑的实现类，更加面向接口开发，此时我们的系统已经非常灵活了，但是我们为了更好的实现Struts框架的雏形，我们提出了第三个问题，如上面代码中显示的一样，所有的转向页面都写死了，我们需要显示和控制分离，如果想换一个视图，要修改Action实现类的代码。

       到现在为止，我们已经实现了一个Struts框架的雏形，只是还不够完美，下篇博客，我们继续完善所有的转向页面，将显示和控制分离。下篇博客【SSH进阶之路】一步步重构MVC实现Struts框架——完善转向页面，大功告成（六）。

源码下载