JavaWeb學習總結(四十九)——簡單模擬Sping MVC

本文轉載自查看原文 2014-11-22 12:53 35625 JavaWeb學習總結

　　在Spring MVC中，將一個普通的java類標注上Controller注解之后，再將類中的方法使用RequestMapping注解標注，那么這個普通的java類就夠處理Web請求，示例代碼如下：

 1 /**
 2  * 使用Controller注解標注LoginUI類
 3  */
 4 @Controller
 5 public class LoginUI {
 6     
 7     //使用RequestMapping注解指明forward1方法的訪問路徑  
 8     @RequestMapping("LoginUI/Login2")
 9     public View forward1(){
10         //執行完forward1方法之后返回的視圖
11         return new View("/login2.jsp");  
12     }
13     
14     //使用RequestMapping注解指明forward2方法的訪問路徑  
15     @RequestMapping("LoginUI/Login3")
16     public View forward2(){
17         //執行完forward2方法之后返回的視圖
18         return new View("/login3.jsp");  
19     } 
20 }

　　spring通過java annotation就可以注釋一個類為action ，在方法上添加上一個java annotation 就可以配置請求的路徑了，那么這種機制是如何實現的呢，今天我們使用"自定義注解+Servlet"來簡單模擬一下Spring MVC中的這種注解配置方式。

一、編寫注解

1.1、Controller注解

　　開發Controller注解，這個注解只有一個value屬性，默認值為空字符串，代碼如下：

 1 package me.gacl.annotation;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 /**
 9 * @ClassName: Controller
10 * @Description: 自定義Controller注解
11 * @author: 孤傲蒼狼
12 * @date: 2014-11-16 下午6:16:40
13 *
14 */ 
15 @Retention(RetentionPolicy.RUNTIME)
16 @Target(ElementType.TYPE)
17 public @interface Controller {
18 
19     public String value() default "";
20 }

1.2、RequestMapping注解

　　開發RequestMapping注解，用於定義請求路徑，這個注解只有一個value屬性，默認值為空字符串，代碼如下：

 1 package me.gacl.annotation;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 /**
 9  * 定義請求路徑的java annotation
10  */
11 @Target(ElementType.METHOD) 
12 @Retention(RetentionPolicy.RUNTIME)  
13 public @interface RequestMapping {
14 
15     public String value() default "";
16 }

　　以上就是我們自定義的兩個注解，注解的開發工作就算是完成了，有了注解之后，那么就必須針對注解來編寫處理器，否則我們開發的注解配置到類或者方法上面是不起作用的，這里我們使用Servlet來作為注解的處理器。

二、編寫核心的注解處理器

2.1、開發AnnotationHandleServlet

　　這里使用一個Servlet來作為注解處理器，編寫一個AnnotationHandleServlet，代碼如下：

  1 package me.gacl.web.controller;
  2 
  3 import java.io.IOException;
  4 import java.lang.reflect.InvocationTargetException;
  5 import java.lang.reflect.Method;
  6 import java.util.Set;
  7 import javax.servlet.ServletConfig;
  8 import javax.servlet.ServletException;
  9 import javax.servlet.http.HttpServlet;
 10 import javax.servlet.http.HttpServletRequest;
 11 import javax.servlet.http.HttpServletResponse;
 12 import me.gacl.annotation.Controller;
 13 import me.gacl.annotation.RequestMapping;
 14 import me.gacl.util.BeanUtils;
 15 import me.gacl.util.RequestMapingMap;
 16 import me.gacl.util.ScanClassUtil;
 17 import me.gacl.web.context.WebContext;
 18 import me.gacl.web.view.DispatchActionConstant;
 19 import me.gacl.web.view.View;
 20 
 21 /**
 22  * <p>ClassName: AnnotationHandleServlet<p>
 23  * <p>Description: AnnotationHandleServlet作為自定義注解的核心處理器以及負責調用目標業務方法處理用戶請求<p>
 24  * @author xudp
 25  * @version 1.0 V
 26  */
 27 public class AnnotationHandleServlet extends HttpServlet {
 28     
 29     private String pareRequestURI(HttpServletRequest request){
 30         String path = request.getContextPath()+"/";
 31         String requestUri = request.getRequestURI();
 32         String midUrl = requestUri.replaceFirst(path, "");
 33         String lasturl = midUrl.substring(0, midUrl.lastIndexOf("."));
 34         return lasturl;
 35     }
 36     
 37     public void doGet(HttpServletRequest request, HttpServletResponse response)
 38             throws ServletException, IOException {
 39         this.excute(request, response);
 40     }
 41 
 42     public void doPost(HttpServletRequest request, HttpServletResponse response)
 43             throws ServletException, IOException {
 44         this.excute(request, response);
 45     }
 46     
 47     private void excute(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
 48         //將當前線程中HttpServletRequest對象存儲到ThreadLocal中，以便在Controller類中使用
 49         WebContext.requestHodler.set(request);
 50         //將當前線程中HttpServletResponse對象存儲到ThreadLocal中，以便在Controller類中使用
 51         WebContext.responseHodler.set(response);
 52         //解析url
 53         String lasturl = pareRequestURI(request);
 54         //獲取要使用的類
 55         Class<?> clazz = RequestMapingMap.getRequesetMap().get(lasturl);
 56         //創建類的實例
 57         Object classInstance = BeanUtils.instanceClass(clazz);
 58         //獲取類中定義的方法
 59         Method [] methods = BeanUtils.findDeclaredMethods(clazz);
 60         Method method = null;
 61         for(Method m:methods){//循環方法，找匹配的方法進行執行
 62             if(m.isAnnotationPresent(RequestMapping.class)){
 63                 String anoPath = m.getAnnotation(RequestMapping.class).value();
 64                 if(anoPath!=null && !"".equals(anoPath.trim()) && lasturl.equals(anoPath.trim())){
 65                     //找到要執行的目標方法
 66                     method = m;
 67                     break;
 68                 }
 69             }
 70         }
 71         try {
 72             if(method!=null){
 73                 //執行目標方法處理用戶請求
 74                 Object retObject = method.invoke(classInstance);
 75                 //如果方法有返回值，那么就表示用戶需要返回視圖
 76                 if (retObject!=null) {
 77                     View view = (View)retObject;
 78                     //判斷要使用的跳轉方式
 79                     if(view.getDispathAction().equals(DispatchActionConstant.FORWARD)){
 80                         //使用服務器端跳轉方式
 81                         request.getRequestDispatcher(view.getUrl()).forward(request, response);
 82                     }else if(view.getDispathAction().equals(DispatchActionConstant.REDIRECT)){
 83                         //使用客戶端跳轉方式
 84                         response.sendRedirect(request.getContextPath()+view.getUrl());
 85                     }else{
 86                         request.getRequestDispatcher(view.getUrl()).forward(request, response);
 87                     }
 88                 }
 89             }
 90         } catch (IllegalArgumentException e) {
 91             e.printStackTrace();
 92         } catch (IllegalAccessException e) {
 93             e.printStackTrace();
 94         } catch (InvocationTargetException e) {
 95             e.printStackTrace();
 96         }
 97     }
 98 
 99     @Override
100     public void init(ServletConfig config) throws ServletException {
101         /**
102          * 重寫了Servlet的init方法后一定要記得調用父類的init方法，
103          * 否則在service/doGet/doPost方法中使用getServletContext()方法獲取ServletContext對象時
104          * 就會出現java.lang.NullPointerException異常
105          */
106         super.init(config); 
107         System.out.println("---初始化開始---");
108         //獲取web.xml中配置的要掃描的包
109         String basePackage = config.getInitParameter("basePackage");
110         //如果配置了多個包，例如：<param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
111         if (basePackage.indexOf(",")>0) {
112             //按逗號進行分隔
113             String[] packageNameArr = basePackage.split(",");
114             for (String packageName : packageNameArr) {
115                 initRequestMapingMap(packageName);
116             }
117         }else {
118             initRequestMapingMap(basePackage);
119         }
120         System.out.println("----初始化結束---");
121     }
122     
123     /**
124     * @Method: initRequestMapingMap
125     * @Description:添加使用了Controller注解的Class到RequestMapingMap中
126     * @Anthor:孤傲蒼狼
127     * @param packageName
128     */ 
129     private void initRequestMapingMap(String packageName){
130         Set<Class<?>> setClasses =  ScanClassUtil.getClasses(packageName);
131         for (Class<?> clazz :setClasses) {
132             if (clazz.isAnnotationPresent(Controller.class)) {
133                 Method [] methods = BeanUtils.findDeclaredMethods(clazz);
134                 for(Method m:methods){//循環方法，找匹配的方法進行執行
135                     if(m.isAnnotationPresent(RequestMapping.class)){
136                         String anoPath = m.getAnnotation(RequestMapping.class).value();
137                         if(anoPath!=null && !"".equals(anoPath.trim())){
138                             if (RequestMapingMap.getRequesetMap().containsKey(anoPath)) {
139                                 throw new RuntimeException("RequestMapping映射的地址不允許重復！");
140                             }
141                             RequestMapingMap.put(anoPath, clazz);
142                         }
143                     }
144                 }
145             }
146         }
147     }
148 }

　　這里說一下AnnotationHandleServlet的實現思路

　　1、AnnotationHandleServlet初始化(init)時掃描指定的包下面使用了Controller注解的類，如下圖所示：

　　2、遍歷類中的方法，找到類中使用了RequestMapping注解標注的那些方法，獲取RequestMapping注解的value屬性值，value屬性值指明了該方法的訪問路徑，以RequestMapping注解的value屬性值作為key，Class類作為value將存儲到一個靜態Map集合中。如下圖所示：

　　當用戶請求時(無論是get還是post請求)，會調用封裝好的execute方法，execute會先獲取請求的url，然后解析該URL，根據解析好的URL從Map集合中取出要調用的目標類，再遍歷目標類中定義的所有方法，找到類中使用了RequestMapping注解的那些方法，判斷方法上面的RequestMapping注解的value屬性值是否和解析出來的URL路徑一致,如果一致，說明了這個就是要調用的目標方法，此時就可以利用java反射機制先實例化目標類對象，然后再通過實例化對象調用要執行的方法處理用戶請求。服務器將以下圖的方式與客戶端進行交互

　　另外，方法處理完成之后需要給客戶端發送響應信息，比如告訴客戶端要跳轉到哪一個頁面，采用的是服務器端跳轉還是客戶端方式跳轉，或者發送一些數據到客戶端顯示，那么該如何發送響應信息給客戶端呢，在此，我們可以設計一個View(視圖)類，對這些操作屬性進行封裝，其中包括跳轉的路徑、展現到頁面的數據、跳轉方式。這就是AnnotationHandleServlet的實現思路。

2.2、在Web.xml文件中注冊AnnotationHandleServlet

　　在web.xml文件中配置AnnotationHandleServlet和需要掃描的包

 1 <servlet>
 2     <servlet-name>AnnotationHandleServlet</servlet-name>
 3     <servlet-class>me.gacl.web.controller.AnnotationHandleServlet</servlet-class>
 4     <init-param>
 5          <description>配置要掃描包及其子包, 如果有多個包,以逗號分隔</description>
 6         <param-name>basePackage</param-name>
 7         <param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
 8         <!-- <param-value>me.gacl.web.controller</param-value> -->
 9     </init-param>
10     <load-on-startup>1</load-on-startup>
11   </servlet>
12 
13   <servlet-mapping>
14     <servlet-name>AnnotationHandleServlet</servlet-name>
15     <!-- 攔截所有以.do后綴結尾的請求 -->
16     <url-pattern>*.do</url-pattern>
17   </servlet-mapping>

三、相關代碼講解

3.1、BeanUtils

　　BeanUtils工具類主要是用來處理一些反射的操作

 1 package me.gacl.util;
 2 
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.Field;
 5 import java.lang.reflect.InvocationTargetException;
 6 import java.lang.reflect.Method;
 7 import java.lang.reflect.Modifier;
 8 
 9 /**
10  * 對java反射中操作的一些封裝
11  */
12 public class BeanUtils {
13     
14     /**
15      * 實例化一個class 
16      * @param <T>
17      * @param clazz Person.class
18      * @return
19      */
20     public static <T> T instanceClass(Class<T> clazz){
21         if(!clazz.isInterface()){
22             try {
23                 return clazz.newInstance();
24             } catch (InstantiationException e) {
25                 e.printStackTrace();
26             } catch (IllegalAccessException e) {
27                 e.printStackTrace();
28             }
29         }
30         return null;
31     }
32     
33     /**
34      * 通過構造函數實例化
35      * @param <T>
36      * @param ctor
37      * @param args
38      * @return
39      * @throws IllegalArgumentException
40      * @throws InstantiationException
41      * @throws IllegalAccessException
42      * @throws InvocationTargetException
43      */
44     public static <T> T instanceClass(Constructor<T> ctor, Object... args)
45             throws IllegalArgumentException, InstantiationException, 
46             IllegalAccessException, InvocationTargetException{
47         makeAccessible(ctor);
48         return ctor.newInstance(args);//調用構造方法實例化
49     }
50     
51     /**
52      * 查找某個class的方法
53      * @param clazz
54      * @param methodName
55      * @param paramTypes
56      * @return
57      * @throws SecurityException
58      * @throws NoSuchMethodException
59      */
60     public static  Method findMethod(Class<?> clazz, String methodName, Class<?>... paramTypes){
61         try {
62             return clazz.getMethod(methodName, paramTypes);
63         } catch (NoSuchMethodException e) {
64             return findDeclaredMethod(clazz, methodName, paramTypes);//返回共有的方法
65         }
66     }
67     
68     public static Method findDeclaredMethod(Class<?> clazz, String methodName, Class<?>[] paramTypes){
69         try {
70             return clazz.getDeclaredMethod(methodName, paramTypes);
71         }
72         catch (NoSuchMethodException ex) {
73             if (clazz.getSuperclass() != null) {
74                 return findDeclaredMethod(clazz.getSuperclass(), methodName, paramTypes);
75             }
76             return null;
77         }
78     }
79     
80     public static Method [] findDeclaredMethods(Class<?> clazz){
81             return clazz.getDeclaredMethods();
82     }
83     
84     public static void makeAccessible(Constructor<?> ctor) {
85         if ((!Modifier.isPublic(ctor.getModifiers()) 
86                 || !Modifier.isPublic(ctor.getDeclaringClass().getModifiers()))
87                 && !ctor.isAccessible()) {
88             ctor.setAccessible(true);//如果是私有的 設置為true 使其可以訪問
89         }
90     }
91     
92     public static Field[] findDeclaredFields(Class<?> clazz){
93         return clazz.getDeclaredFields();
94     }
95 }

3.2、RequestMapingMap

　　該類是用於存儲方法的訪問路徑，AnnotationHandleServlet初始化時會將類(使用Controller注解標注的那些類)中使用了RequestMapping注解標注的那些方法的訪問路徑存儲到RequestMapingMap中。

 1 package me.gacl.util;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 
 6 /**
 7 * @ClassName: RequestMapingMap
 8 * @Description: 存儲方法的訪問路徑
 9 * @author: 孤傲蒼狼
10 * @date: 2014-11-16 下午6:31:43
11 *
12 */ 
13 public class RequestMapingMap {
14 
15     /**
16     * @Field: requesetMap
17     *          用於存儲方法的訪問路徑
18     */ 
19     private static Map<String, Class<?>> requesetMap = new HashMap<String, Class<?>>();
20     
21     public static Class<?> getClassName(String path) {
22         return requesetMap.get(path);
23     }
24 
25     public static void put(String path, Class<?> className) {
26         requesetMap.put(path, className);
27     }
28 
29     public static Map<String, Class<?>> getRequesetMap() {
30         return requesetMap;
31     }
32 }

3.3、ScanClassUtil

　　掃描某個包下面的類的工具類

  1 package me.gacl.util;
  2 
  3 import java.io.File;
  4 import java.io.FileFilter;
  5 import java.io.IOException;
  6 import java.net.JarURLConnection;
  7 import java.net.URL;
  8 import java.net.URLDecoder;
  9 import java.util.Enumeration;
 10 import java.util.LinkedHashSet;
 11 import java.util.Set;
 12 import java.util.jar.JarEntry;
 13 import java.util.jar.JarFile;
 14 
 15 /**
 16 * @ClassName: ScanClassUtil
 17 * @Description: 掃描指定包或者jar包下面的class
 18 * @author: 孤傲蒼狼
 19 * @date: 2014-11-16 下午6:34:10
 20 *
 21 */ 
 22 public class ScanClassUtil {
 23 
 24     /**
 25      * 從包package中獲取所有的Class
 26      * 
 27      * @param pack
 28      * @return
 29      */
 30     public static Set<Class<?>> getClasses(String pack) {
 31 
 32         // 第一個class類的集合
 33         Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
 34         // 是否循環迭代
 35         boolean recursive = true;
 36         // 獲取包的名字 並進行替換
 37         String packageName = pack;
 38         String packageDirName = packageName.replace('.', '/');
 39         // 定義一個枚舉的集合 並進行循環來處理這個目錄下的things
 40         Enumeration<URL> dirs;
 41         try {
 42             dirs = Thread.currentThread().getContextClassLoader().getResources(
 43                     packageDirName);
 44             // 循環迭代下去
 45             while (dirs.hasMoreElements()) {
 46                 // 獲取下一個元素
 47                 URL url = dirs.nextElement();
 48                 // 得到協議的名稱
 49                 String protocol = url.getProtocol();
 50                 // 如果是以文件的形式保存在服務器上
 51                 if ("file".equals(protocol)) {
 52                     System.err.println("file類型的掃描");
 53                     // 獲取包的物理路徑
 54                     String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
 55                     // 以文件的方式掃描整個包下的文件 並添加到集合中
 56                     findAndAddClassesInPackageByFile(packageName, filePath,
 57                             recursive, classes);
 58                 } else if ("jar".equals(protocol)) {
 59                     // 如果是jar包文件
 60                     // 定義一個JarFile
 61                     System.err.println("jar類型的掃描");
 62                     JarFile jar;
 63                     try {
 64                         // 獲取jar
 65                         jar = ((JarURLConnection) url.openConnection())
 66                                 .getJarFile();
 67                         // 從此jar包 得到一個枚舉類
 68                         Enumeration<JarEntry> entries = jar.entries();
 69                         // 同樣的進行循環迭代
 70                         while (entries.hasMoreElements()) {
 71                             // 獲取jar里的一個實體 可以是目錄 和一些jar包里的其他文件 如META-INF等文件
 72                             JarEntry entry = entries.nextElement();
 73                             String name = entry.getName();
 74                             // 如果是以/開頭的
 75                             if (name.charAt(0) == '/') {
 76                                 // 獲取后面的字符串
 77                                 name = name.substring(1);
 78                             }
 79                             // 如果前半部分和定義的包名相同
 80                             if (name.startsWith(packageDirName)) {
 81                                 int idx = name.lastIndexOf('/');
 82                                 // 如果以"/"結尾 是一個包
 83                                 if (idx != -1) {
 84                                     // 獲取包名 把"/"替換成"."
 85                                     packageName = name.substring(0, idx)
 86                                             .replace('/', '.');
 87                                 }
 88                                 // 如果可以迭代下去 並且是一個包
 89                                 if ((idx != -1) || recursive) {
 90                                     // 如果是一個.class文件 而且不是目錄
 91                                     if (name.endsWith(".class")
 92                                             && !entry.isDirectory()) {
 93                                         // 去掉后面的".class" 獲取真正的類名
 94                                         String className = name.substring(
 95                                                 packageName.length() + 1, name
 96                                                         .length() - 6);
 97                                         try {
 98                                             // 添加到classes
 99                                             classes.add(Class
100                                                     .forName(packageName + '.'
101                                                             + className));
102                                         } catch (ClassNotFoundException e) {
103                                             // log
104                                             // .error("添加用戶自定義視圖類錯誤 找不到此類的.class文件");
105                                             e.printStackTrace();
106                                         }
107                                     }
108                                 }
109                             }
110                         }
111                     } catch (IOException e) {
112                         // log.error("在掃描用戶定義視圖時從jar包獲取文件出錯");
113                         e.printStackTrace();
114                     }
115                 }
116             }
117         } catch (IOException e) {
118             e.printStackTrace();
119         }
120 
121         return classes;
122     }
123     
124     /**
125      * 以文件的形式來獲取包下的所有Class
126      * 
127      * @param packageName
128      * @param packagePath
129      * @param recursive
130      * @param classes
131      */
132     public static void findAndAddClassesInPackageByFile(String packageName,
133             String packagePath, final boolean recursive, Set<Class<?>> classes) {
134         // 獲取此包的目錄 建立一個File
135         File dir = new File(packagePath);
136         // 如果不存在或者 也不是目錄就直接返回
137         if (!dir.exists() || !dir.isDirectory()) {
138             // log.warn("用戶定義包名 " + packageName + " 下沒有任何文件");
139             return;
140         }
141         // 如果存在 就獲取包下的所有文件 包括目錄
142         File[] dirfiles = dir.listFiles(new FileFilter() {
143             // 自定義過濾規則 如果可以循環(包含子目錄) 或則是以.class結尾的文件(編譯好的java類文件)
144             public boolean accept(File file) {
145                 return (recursive && file.isDirectory())
146                         || (file.getName().endsWith(".class"));
147             }
148         });
149         // 循環所有文件
150         for (File file : dirfiles) {
151             // 如果是目錄 則繼續掃描
152             if (file.isDirectory()) {
153                 findAndAddClassesInPackageByFile(packageName + "."
154                         + file.getName(), file.getAbsolutePath(), recursive,
155                         classes);
156             } else {
157                 // 如果是java類文件 去掉后面的.class 只留下類名
158                 String className = file.getName().substring(0,
159                         file.getName().length() - 6);
160                 try {
161                     // 添加到集合中去
162                     //classes.add(Class.forName(packageName + '.' + className));
163                      //經過回復同學的提醒，這里用forName有一些不好，會觸發static方法，沒有使用classLoader的load干凈
164                     classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));  
165                     } catch (ClassNotFoundException e) {
166                     // log.error("添加用戶自定義視圖類錯誤 找不到此類的.class文件");
167                     e.printStackTrace();
168                 }
169             }
170         }
171     }
172 }

3.4、WebContext

　　WebContext主要是用來存儲當前線程中的HttpServletRequest和HttpServletResponse，當別的地方需要使用HttpServletRequest和HttpServletResponse，就可以通過requestHodler和responseHodler獲取，通過WebContext.java這個類，我們可以在作為Controller的普通java類中獲取當前請求的request、response或者session相關請求類的實例變量，並且線程間互不干擾的，因為用到了ThreadLocal這個類。

 1 package me.gacl.web.context;
 2 
 3 import javax.servlet.ServletContext;
 4 import javax.servlet.http.HttpServletRequest;
 5 import javax.servlet.http.HttpServletResponse;
 6 import javax.servlet.http.HttpSession;
 7 
 8 /**
 9  * WebContext主要是用來存儲當前線程中的HttpServletRequest和HttpServletResponse
10  * 當別的地方需要使用HttpServletRequest和HttpServletResponse，就可以通過requestHodler和responseHodler獲取
11  **/
12 public class WebContext {
13 
14     public static ThreadLocal<HttpServletRequest> requestHodler = new ThreadLocal<HttpServletRequest>();
15     public static ThreadLocal<HttpServletResponse> responseHodler = new ThreadLocal<HttpServletResponse>();
16    
17     public HttpServletRequest getRequest(){
18            return requestHodler.get();
19     }
20    
21     public HttpSession getSession(){
22            return requestHodler.get().getSession();
23     }
24    
25     public ServletContext getServletContext(){
26            return requestHodler.get().getSession().getServletContext();
27     }
28     
29     public HttpServletResponse getResponse(){
30         return responseHodler.get();
31     }
32 }

3.5、View

　　一個視圖類，對一些客戶端響應操作進行封裝，其中包括跳轉的路徑、展現到頁面的數據、跳轉方式

 1 package me.gacl.web.view;
 2 
 3 /**
 4  * 視圖模型
 5  **/
 6 public class View {
 7 
 8     private String url;//跳轉路徑
 9     
10     private String dispathAction = DispatchActionConstant.FORWARD;//跳轉方式
11 
12     public View(String url) {
13         this.url = url;
14     }
15     
16     public View(String url,String name,Object value) {
17         this.url = url;
18         ViewData view = new ViewData();
19         view.put(name, value);
20     }
21     
22     
23     public View(String url,String name,String dispathAction ,Object value) {
24         this.dispathAction = dispathAction;
25         this.url = url;
26         ViewData view = new ViewData();//請看后面的代碼
27         view.put(name, value);
28     }
29     
30     
31     public String getUrl() {
32         return url;
33     }
34     
35     
36     public void setUrl(String url) {
37         this.url = url;
38     }
39 
40     public String getDispathAction() {
41         return dispathAction;
42     }
43 
44     public void setDispathAction(String dispathAction) {
45         this.dispathAction = dispathAction;
46     }
47 }

3.6、ViewData

　　request范圍的數據存儲類，當需要發送數據到客戶端顯示時，就可以將要顯示的數據存儲到ViewData類中。使用ViewData.put(String name,Object value)方法往request對象中存數據。

 1 package me.gacl.web.view;
 2 
 3 import javax.servlet.http.HttpServletRequest;
 4 
 5 import me.gacl.web.context.WebContext;
 6 
 7 /**
 8  * 需要發送到客戶端顯示的數據模型
 9  */
10 public class ViewData {
11     
12     private HttpServletRequest request;
13     
14     public ViewData() {
15         initRequest();
16     }
17 
18     private void initRequest(){
19         //從requestHodler中獲取request對象
20         this.request = WebContext.requestHodler.get();
21     }
22     
23     public void put(String name,Object value){
24         this.request.setAttribute(name, value);
25     }
26 }

3.7、DispatchActionConstant

　　一個跳轉方式的常量類

 1 package me.gacl.web.view;
 2 
 3 /**
 4  * 跳轉常量
 5  */
 6 public class DispatchActionConstant {
 7 
 8     public static String FORWARD = "forward";//服務器跳轉
 9     
10     public static String REDIRECT = "redirect";//客戶端跳轉
11 }

四、Controller注解和RequestMapping注解測試

4.1、簡單測試

　　編寫一個LoginUI類，用於跳轉到具體的jsp頁面，代碼如下：

 1 package me.gacl.web.UI;
 2 
 3 import me.gacl.annotation.Controller;
 4 import me.gacl.annotation.RequestMapping;
 5 import me.gacl.web.view.View;
 6 /**
 7  * 使用Controller注解標注LoginUI類
 8  */
 9 @Controller
10 public class LoginUI {
11     
12     //使用RequestMapping注解指明forward1方法的訪問路徑  
13     @RequestMapping("LoginUI/Login2")
14     public View forward1(){
15         //執行完forward1方法之后返回的視圖
16         return new View("/login2.jsp");  
17     }
18     
19     //使用RequestMapping注解指明forward2方法的訪問路徑  
20     @RequestMapping("LoginUI/Login3")
21     public View forward2(){
22         //執行完forward2方法之后返回的視圖
23         return new View("/login3.jsp");  
24     } 
25 }

　　運行結果如下所示：

4.2、復雜測試

　　編寫用於處理用戶登錄請求的Controller，代碼如下：

 1 package me.gacl.web.controller;
 2 
 3 import java.io.IOException;
 4 import javax.servlet.http.HttpServletRequest;
 5 import javax.servlet.http.HttpServletResponse;
 6 import me.gacl.annotation.Controller;
 7 import me.gacl.annotation.RequestMapping;
 8 import me.gacl.web.context.WebContext;
 9 import me.gacl.web.view.View;
10 import me.gacl.web.view.ViewData;
11 
12 /**
13 * 
14 * @ClassName: LoginServlet2
15 * @Description:處理用戶登錄的Servlet，
16 * LoginServlet現在就是一個普通的java類，不是一個真正的Servlet
17 * @author: 孤傲蒼狼
18 * @date: 2014-10-8 上午12:07:58
19 *
20 */
21 @Controller //使用Controller注解標注LoginServlet2
22 public class LoginServlet2 {
23 
24     /**
25     * @Method: loginHandle
26     * @Description:處理以普通方式提交的請求
27     * @Anthor:孤傲蒼狼
28     *
29     * @return View
30     */
31     //使用RequestMapping注解標注loginHandle方法，指明loginHandle方法的訪問路徑是login/handle
32     @RequestMapping("login/handle")
33     public View loginHandle(){
34         //創建一個ViewData對象，用於存儲需要發送到客戶端的響應數據
35         ViewData viewData = new ViewData();
36         //通過WebContext類獲取當前線程中的HttpServletRequest對象
37         HttpServletRequest request = WebContext.requestHodler.get();
38         //接收提交上來的參數
39         String username =request.getParameter("usename");
40         String pwd = request.getParameter("pwd");
41         if (username.equals("gacl") && pwd.equals("xdp")) {
42             request.getSession().setAttribute("usename", username);
43             //將響應數據存儲到ViewData對象中
44             viewData.put("msg", "歡迎您！"+username);
45             //返回一個View對象，指明要跳轉的視圖的路徑
46             return new View("/index.jsp");
47         }else {
48             //將響應數據存儲到ViewData對象中
49             viewData.put("msg", "登錄失敗，請檢查用戶名和密碼是否正確！");
50             //返回一個View對象，指明要跳轉的視圖的路徑
51             return new View("/login2.jsp");
52         }
53     }
54     
55     /**
56     * @Method: ajaxLoginHandle
57     * @Description: 處理以AJAX方式提交的請求
58     * @Anthor:孤傲蒼狼
59     *
60     * @throws IOException
61     */ 
62     //使用RequestMapping注解標注ajaxLoginHandle方法，指明ajaxLoginHandle方法的訪問路徑是ajaxLogin/handle
63     @RequestMapping("ajaxLogin/handle")
64     public void ajaxLoginHandle() throws IOException{
65         //通過WebContext類獲取當前線程中的HttpServletRequest對象
66         HttpServletRequest request = WebContext.requestHodler.get();
67         //接收提交上來的參數
68         String username =request.getParameter("usename");
69         String pwd = request.getParameter("pwd");
70         //通過WebContext類獲取當前線程中的HttpServletResponse對象
71         HttpServletResponse response = WebContext.responseHodler.get();
72         if (username.equals("gacl") && pwd.equals("xdp")) {
73             request.getSession().setAttribute("usename", username);
74             response.getWriter().write("success");
75         }else {
76             response.getWriter().write("fail");
77         }
78     }
79 }

　　編寫用於測試的jsp頁面，代碼如下所示：

　　Login2.jsp登錄頁面

 1 <%@ page language="java" pageEncoding="UTF-8"%>
 2 <!DOCTYPE HTML>
 3 <html>
 4   <head>
 5     <title>login2.jsp登錄頁面</title>
 6   </head>
 7   
 8   <body>
 9     <fieldset>
10         <legend>用戶登錄</legend>
11         <form action="${pageContext.request.contextPath}/login/handle.do" method="post">
12             用戶名：<input type="text" value="${param.usename}" name="usename">
13             <br/>
14             密碼：<input type="text" value="${param.pwd}" name="pwd">
15             <br/>
16             <input type="submit" value="登錄"/>
17         </form>
18     </fieldset>
19     <hr/>
20     <label style="color: red;">${msg}</label>
21   </body>
22 </html>

　　login3.jsp登錄頁面

 1 <%@ page language="java" pageEncoding="UTF-8"%>
 2 <!DOCTYPE HTML>
 3 <html>
 4   <head>
 5     <title>login3登錄頁面</title>
 6     <script type="text/javascript" src="${pageContext.request.contextPath}/ajaxUtil.js"></script>
 7     <script type="text/javascript" src="${pageContext.request.contextPath}/js/Utils.js"></script>
 8     <script type="text/javascript">
 9     
10         function login(){
11              Ajax.request({
12                  url : "${pageContext.request.contextPath}/ajaxLogin/handle.do",
13                  data : {
14                      "usename" : document.getElementById("usename").value,
15                      "pwd" : document.getElementById("pwd").value
16                  },
17                  success : function(xhr) {
18                      onData(xhr.responseText);
19                  },
20                  error : function(xhr) {
21                      
22                  }
23              });
24         }
25         
26         function onData(responseText){
27             if(responseText=="success"){
28                 //window.location.href="index.jsp";//改變url地址
29                 /*
30                 window.location.replace("url")：將地址替換成新url，
31                 該方法通過指定URL替換當前緩存在歷史里（客戶端）的項目，因此當使用replace方法之后，
32                 你不能通過“前進”和“后 退”來訪問已經被替換的URL，這個特點對於做一些過渡頁面非常有用！
33                 */
34                 location.replace(g_basePath+"/index.jsp");
35             }else{
36                 alert("用戶名和密碼錯誤");
37             }
38         }
39     </script>
40   </head>
41   
42   <body>
43     <fieldset>
44         <legend>用戶登錄</legend>
45         <form>
46             用戶名：<input type="text" name="usename" id="usename">
47             <br/>
48             密碼：<input type="text" name="pwd" id="pwd">
49             <br/>
50             <input type="button" value="登錄" onclick="login()"/>
51         </form>
52     </fieldset>
53   </body>
54 </html>

　　index.jsp頁面代碼如下：

 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 2 
 3 <!DOCTYPE HTML>
 4 <html>
 5   <head>
 6     <title>首頁</title>
 7   </head>
 8   
 9   <body>
10         登錄的用戶名：${usename}
11     <br/>
12     ${msg}
13   </body>
14 </html>

　　jsp頁面中使用到的Utils.js代碼如下：

 1 //立即執行的js
 2 (function() {
 3     //獲取contextPath
 4     var contextPath = getContextPath();
 5     //獲取basePath
 6     var basePath = getBasePath();
 7     //將獲取到contextPath和basePath分別賦值給window對象的g_contextPath屬性和g_basePath屬性
 8     window.g_contextPath = contextPath;
 9     window.g_basePath = basePath;
10 })();
11 
12 /**
13  * @author 孤傲蒼狼
14  * 獲得項目根路徑，等價於jsp頁面中
15  *  <%
16         String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
17     %>
18  * 使用方法：getBasePath();
19  * @returns 項目的根路徑
20  *  
21  */
22 function getBasePath() {
23     var curWwwPath = window.document.location.href;
24     var pathName = window.document.location.pathname;
25     var pos = curWwwPath.indexOf(pathName);
26     var localhostPath = curWwwPath.substring(0, pos);
27     var projectName = pathName.substring(0, pathName.substr(1).indexOf('/') + 1);
28     return (localhostPath + projectName);
29 }
30 
31 /**
32  * @author 孤傲蒼狼
33  * 獲取Web應用的contextPath，等價於jsp頁面中
34  *  <%
35         String path = request.getContextPath();
36     %>
37  * 使用方法:getContextPath();
38  * @returns /項目名稱(/EasyUIStudy_20141104)
39  */
40 function getContextPath() {
41     return window.document.location.pathname.substring(0, window.document.location.pathname.indexOf('\/', 1));
42 };

　　測試結果如下：

　　以上就是對Spring MVC的簡單模擬。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 javaweb學習總結(十九)——JSP標簽 javaweb學習總結(二十九)——EL表達式 Deep learning：四十九(RNN-RBM簡單理解) 【WPF學習】第四十九章基本動畫 Python 簡單模擬斗地主發牌簡單模擬三層內網滲透簡單模擬醫院叫號系統 PAT/簡單模擬習題集（一）第四十九篇入門機器學習——數據歸一化（Feature Scaling） javaweb學習總結(三十九)——數據庫連接池