关闭

深入浅出学习Struts框架(三):彻底去掉TestServlet中的字符串和if-else语句块 .

标签: struts框架pathactionstringmvc
208人阅读 评论(0) 收藏 举报
分类:
在《深入浅出学习Struts框架(一):一个简单mvc模式代码示例开始》和《深入浅出学习Struts框架(二):重构MVC模式代码中跳转路径和业务逻辑》文章中已经说了分层和mvc模式的区别,和一些为了去掉mvc模式代码中的TestServlet类中的if-else。因为if-else在程序代码中是相对不稳定的,所以通过去掉if-else来引入对struts框架的学习。


       在《深入浅出学习Struts框架(二):重构MVC模式代码中跳转路径和业务逻辑》中我们已经抽象出来了一个接口和四个实现类,主要封装了业务处理和页面跳转路径字符串放回,以便利用多肽来重构了TestServlet代码(具体见博客)。

 

        在上两篇博客我们遗留了两个问题,一是if-else,二是字符串太多。今天这篇博客就要解决这两个问题。


        上一篇TestServlet重构后的代码:

         

  1. package com.cjq.servlet;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.List;  
  5.   
  6. import javax.servlet.ServletException;  
  7. import javax.servlet.http.HttpServlet;  
  8. import javax.servlet.http.HttpServletRequest;  
  9. import javax.servlet.http.HttpServletResponse;  
  10.   
  11. public class TestServlet extends HttpServlet {  
  12.   
  13.       
  14.     protected void doGet(HttpServletRequest request, HttpServletResponse response)  
  15.             throws ServletException, IOException {  
  16.           
  17.         String requestURI=request.getRequestURI();  
  18.         System.out.println("request="+requestURI);  
  19.         String path=requestURI.substring(requestURI.indexOf("/",1),requestURI.indexOf("."));  
  20.         System.out.println("path="+path);  
  21.           
  22.   
  23.         Action action=null;  
  24.         if("/servlet/delUser".equals(path)){  
  25.             action=new DelUserAction();  
  26.         }else if("/servlet/addUser".equals(path)){  
  27.             action=new AddUserAction();  
  28.         }else if("/servlet/modifyUser".equals(path)){  
  29.             action=new ModifyUserAction();  
  30.         }else if("/servlet/queryUser".equals(path)){  
  31.             action=new QueryUserAction();  
  32.         }else{  
  33.             throw new RuntimeException("请求失败");  
  34.         }  
  35.         String forward=null;  
  36.         try{  
  37.             forward=action.execute(request, response);  
  38.         }catch(Exception e){  
  39.             e.printStackTrace();  
  40.         }  
  41.         request.getRequestDispatcher(forward).forward(request, response);  
  42.       }  
  43. }  


         解决字符串问题,当然就要用到配置文件了,用到配置文件就要有用来读取配置文件的相关的类和方法,这里就用dom4j中的类来读取配置文件,这里的配置文件的书写是有点逻辑上的难度的。

 

        我们来看TestServlet中的代码,我们要在这个testservlet中实现读取配置文件和path比较,还有利用多肽实例化相应的实现类,最后通过实例化的实现类的方法来返回跳转路径,最终跳转到相应的页面。


        所以我们的配置文件就要不仅配上testservlet中出现的字符串,还要配置相应的Action接口的实现类(我们可以利用反射来实例化该类的对象,进而使用这个类的所有属性和方法),另外还有跳转路径字符串。这样我们的配置文件就变成了如下代码所示:

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <action-config>  
  3.     <action path="/servlet/delUser" type="com.cjq.servlet.DelUserAction">  
  4.         <forward name="success">/del_success.jsp</forward>  
  5.         <forward name="error">/del_error.jsp</forward>  
  6.     </action>  
  7.       
  8.     <action path="/servlet/addUser" type="com.cjq.servlet.AddUserAction">  
  9.         <forward name="success">/add_success.jsp</forward>  
  10.         <forward name="error">/add_error.jsp</forward>  
  11.     </action>  
  12.       
  13.     <action path="/servlet/modifyUser" type="com.cjq.servlet.ModifyUserAction">  
  14.         <forward name="success">/modify_success.jsp</forward>  
  15.         <forward name="error">/modify_error.jsp</forward>  
  16.     </action>  
  17.       
  18.     <action path="/servlet/queryUser" type="com.cjq.servlet.QueryUserAction">  
  19.         <forward name="success">/query_success.jsp</forward>  
  20.         <forward name="error">/query_error.jsp</forward>  
  21.     </action>  
  22.       
  23. </action-config>  


 

        我们有了配置文件之后就要想法通过相关类读取,并且实现相应的功能。所以这里用dom4j来读取完成。其实如果能把这个逻辑捋顺之后就能发现,其实懂我们利用dom4j读取完配置文件的时候,我们是取得的是一个配套的匹配路径字符串、相应业务逻辑类还有处理业务逻辑之后跳转页面路径字符串。这样我们就能直截了当的去掉了if-else。(这里可能逻辑上会出现一些困难,但是看到下面的重构之后的testservlet中的代码和读取配置文件之后的代码就会一目了然)。

 

        现在等待解决的问题就是我们要把从配置文件取得的一整套内容放到那里,当然这是毋庸置疑的要放到类中。所以我们就建立一个ActionMapping类来放我们的那一整套内容。

 

        ActionMapping中的代码如下:

        

  1. package com.cjq.servlet;  
  2.   
  3. import java.util.Map;  
  4.   
  5. public class ActionMapping {  
  6.   
  7.     private String path;  
  8.       
  9.     private Object type;  
  10.       
  11.     private Map forwardMap;  
  12.   
  13.     public String getPath() {  
  14.         return path;  
  15.     }  
  16.   
  17.     public void setPath(String path) {  
  18.         this.path = path;  
  19.     }  
  20.   
  21.     public Object getType() {  
  22.         return type;  
  23.     }  
  24.   
  25.     public void setType(Object type) {  
  26.         this.type = type;  
  27.     }  
  28.   
  29.     public Map getForwardMap() {  
  30.         return forwardMap;  
  31.     }  
  32.   
  33.     public void setForwardMap(Map forwardMap) {  
  34.         this.forwardMap = forwardMap;  
  35.     }  
  36.       
  37. }  


        现在ActionMapping类已经有了,剩下的工作就是要利用dom4j来读取配置文件类,具体代码如下:

        

  1. package com.cjq.servlet;  
  2.   
  3. import java.io.InputStream;  
  4. import java.util.HashMap;  
  5. import java.util.Iterator;  
  6. import java.util.Map;  
  7.   
  8. import org.dom4j.Document;  
  9. import org.dom4j.DocumentException;  
  10. import org.dom4j.Element;  
  11. import org.dom4j.io.SAXReader;  
  12.   
  13. public class XmlConfigReader {  
  14.   
  15.       
  16.     private static XmlConfigReader instance=new XmlConfigReader();  
  17.       
  18.     ActionMapping actionMapping=new ActionMapping();  
  19.       
  20.     private Document doc;  
  21.       
  22.     private Map actionMap=new HashMap();  
  23.       
  24.     private XmlConfigReader(){  
  25.         try {  
  26.             SAXReader reader=new SAXReader();  
  27.               
  28.             InputStream in=Thread.currentThread().getContextClassLoader().getResourceAsStream("action_config.xml");  
  29.               
  30.             doc=reader.read(in);  
  31.               
  32.         } catch (DocumentException e) {  
  33.             // TODO Auto-generated catch block   
  34.             e.printStackTrace();  
  35.         }  
  36.           
  37.           
  38.     }  
  39.       
  40.       
  41.       
  42.       
  43.     public ActionMapping getActionMapping(String path){  
  44.         synchronized(this){  
  45.               
  46.             Object type=null;  
  47.             /*if(action.containsKey(path)){ 
  48.                 type=action.get(path); 
  49.             }*/  
  50.               
  51.               
  52.             Element eltAction = (Element)doc.selectObject("//action[@path=\"" + path + "\"]");  
  53.             try{  
  54.                 type=Class.forName(eltAction.attributeValue("type")).newInstance();  
  55.             }catch(Exception e){  
  56.                 e.printStackTrace();  
  57.             }  
  58.               
  59.              Element eltForwards = eltAction.element("forward");  
  60.                  
  61.                 for (Iterator iter = eltForwards.elementIterator(); iter.hasNext();) {  
  62.                     Element eltForward = (Element) iter.next();  
  63.                     actionMap.put(  eltForward.attributeValue("name"),eltForward.getTextTrim());   
  64.                 }   
  65.               
  66.             actionMapping.setPath(path);  
  67.             actionMapping.setType(type);  
  68.             actionMapping.setForwardMap(actionMap);  
  69.               
  70.             return actionMapping;  
  71.         }  
  72.     }  
  73.       
  74.     public static synchronized XmlConfigReader getInstance(){  
  75.           
  76.         return instance;  
  77.     }  
  78.       
  79.       
  80.     /** 
  81.      * @param args 
  82.      */  
  83.     public static void main(String[] args) {  
  84.         // TODO Auto-generated method stub   
  85.         ActionMapping actionMapping=XmlConfigReader.getInstance().getActionMapping("/servlet/delUser");  
  86.         System.out.println(actionMapping.getPath());  
  87.         System.out.println(actionMapping.getType());  
  88.         System.out.println(actionMapping.getForwardMap().toString());  
  89.     }  
  90.   
  91. }  


        我们通过返回ActionMapping来动态创建出action相应的实现类,进而完成业务逻辑和页面跳转,重构之后的TestServlet代码如下:

        

  1. package com.cjq.servlet;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.List;  
  5.   
  6. import javax.servlet.ServletException;  
  7. import javax.servlet.http.HttpServlet;  
  8. import javax.servlet.http.HttpServletRequest;  
  9. import javax.servlet.http.HttpServletResponse;  
  10.   
  11. public class TestServlet extends HttpServlet {  
  12.   
  13.       
  14.     protected void doGet(HttpServletRequest request, HttpServletResponse response)  
  15.             throws ServletException, IOException {  
  16.           
  17.         String requestURI=request.getRequestURI();  
  18.         System.out.println("request="+requestURI);  
  19.         String path=requestURI.substring(requestURI.indexOf("/",1),requestURI.indexOf("."));  
  20.         System.out.println("path="+path);  
  21.           
  22.   
  23.         String forward="";  
  24.         ActionMapping actionMapping=XmlConfigReader.getInstance().getActionMapping(path);  
  25.         Action action=(Action)actionMapping.getType();  
  26.         try {  
  27.             forward=action.execute(request, response);  
  28.         } catch (Exception e) {  
  29.             // TODO Auto-generated catch block   
  30.             e.printStackTrace();  
  31.         }  
  32.         request.getRequestDispatcher(forward).forward(request, response);  
  33.     }  
  34.   
  35.       
  36.     protected void doPost(HttpServletRequest request, HttpServletResponse response)  
  37.             throws ServletException, IOException {  
  38.         doGet(request,response);  
  39.     }  
  40.   
  41. }  

 

        我们可以清晰的看到if-else已经没有了,字符串也已经没有了。通过这篇文章对if-else还有字符串问题的解决,又一次重构了testservlet代码,程序相对灵活许多。通过这一次的重构,我们已经看到了struts框架的雏形,下一篇文章就真正开始了struts框架的学习。

 

        下一篇引子:

        其实框架就是对程序的高度封装,我们经历了这三篇文章之后,一步一步重构,一步一步封装,逐步向框架靠拢,其实框架没有什么难的,其实没有学习框架之前感觉挺神秘,其实如果一步一步来研究之后发现框架就是封装的高度化,分层的高度化。

       下一篇文章深入浅出学习struts框架(四):从MVC模式代码认识struts框架就借助刚刚完成的实例来简单认识struts框架,看看真正的struts框架和我们这个mvc小实例有什么相同和相异之处。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:84844次
    • 积分:897
    • 等级:
    • 排名:千里之外
    • 原创:4篇
    • 转载:68篇
    • 译文:0篇
    • 评论:7条
    文章分类
    最新评论