JavaWeb学习总结(四十八)——模拟Servlet3.0使用注解的方式配置Servlet

一、Servlet的传统配置方式

　　在JavaWeb开发中，每次编写一个Servlet都需要在web.xml文件中进行配置，如下所示：

11 <servlet>
22     <servlet-name>ActionServlet</servlet-name>
33     <servlet-class>me.gacl.web.controller.ActionServlet</servlet-class>
44 </servlet>
55 
66 <servlet-mapping>
77     <servlet-name>ActionServlet</servlet-name>
88     <url-pattern>/servlet/ActionServlet</url-pattern>
99 </servlet-mapping>

　　每开发一个Servlet，都要在web.xml中配置Servlet才能够使用，这实在是很头疼的事情，所以Servlet3.0之后提供了注解(annotation)，使得不再需要在web.xml文件中进行Servlet的部署描述，简化开发流程。本文所讲的基于注解方式配置Servlet不是针对Servlet3.0的，而是基于Servlet2.5的，通过开发自定义注解和注解处理器来实现类似于Servlet3.0的注解方式配置Servlet。

二、基于注解的方式配置Servlet

　　JDK1. 5版本之后， JAVA提供了一种叫做Annotation的新数据类型，中文译为注解或标注，它的出现为铺天盖地的XML配置文件提供了一个完美的解决方案，让 JAVA EE开发更加方便快速，也更加干净了。不过Servlet2.5默认情况下是不支持注解方式的配置的，但是我们可以开发自定义注解，然后将注解标注到Servlet上，再针对我们自定义的注解写一个注解处理器，具体的做法如下：

2.1、开发用于配置Servlet的相关注解

　　1、开发WebServlet注解，用于标注处理请求的Servlet类

1 1 package me.gacl.annotation;
2 2 
3 3 import java.lang.annotation.ElementType;
4 4 import java.lang.annotation.Retention;
5 5 import java.lang.annotation.RetentionPolicy;
6 6 import java.lang.annotation.Target;
7 7 
8 8 /**
9 9  * 自定义WebServlet注解，模拟Servlet3.0的WebServlet注解
1010  * @Target 注解的属性值表明了 @WebServlet注解只能用于类或接口定义声明的前面， 
1111  * @WebServlet注解有一个必填的属性 value 。
1212  * 调用方式为： @WebServlet(value="/xxxx") ，
1313  * 因语法规定如果属性名为 value 且只填 value属性值时，可以省略 value属性名，即也可以写作：@WebServlet("/xxxx") 
1414  */
1515 @Retention(RetentionPolicy.RUNTIME)
1616 @Target(ElementType.TYPE)
1717 public @interface WebServlet {
1818     //Servlet的访问URL
1919     String value();
2020     //Servlet的访问URL
2121     String[] urlPatterns() default {""};
2222     //Servlet的描述
2323     String description() default "";
2424     //Servlet的显示名称
2525     String displayName() default "";
2626     //Servlet的名称
2727     String name() default "";
2828     //Servlet的init参数
2929     WebInitParam[] initParams() default {};
3030 }

　　将Servlet在web.xml中的配置信息使用WebServlet注解来表示，使用注解后，只需要在相应Servlet 类的前面使用类似@WebServlet("/servlet/LoginServlet") 注解就可以达到和上述 web.xml 文件中配置信息一样的目的。注解@WebServlet中的属性值"/servlet/LoginServlet"表示了web.xml 配置文件中 <servlet-mapping> 元素的子元素 <url-pattern> 里的值。通过这样的注解能简化在 XML 文件中配置 Servlet 信息，整个配置文件将会非常简洁干净，开发人员的工作也将大大减少。

　　2、开发WebInitParam注解，用于配置Servlet初始化时使用的参数

1 1 package me.gacl.annotation;
2 2 
3 3 import java.lang.annotation.ElementType;
4 4 import java.lang.annotation.Retention;
5 5 import java.lang.annotation.RetentionPolicy;
6 6 import java.lang.annotation.Target;
7 7 
8 8 /**
9 9 * @ClassName: WebInitParam
1010 * @Description: 定义Servlet的初始化参数注解
1111 * @author: 孤傲苍狼
1212 * @date: 2014-10-1 下午3:25:53
1313 *
1414 */
1515 @Retention(RetentionPolicy.RUNTIME)
1616 @Target(ElementType.TYPE)
1717 public @interface WebInitParam {
1818     //参数名
1919     String paramName() default "";
2020     //参数的值
2121     String paramValue() default "";
2222 }

2.2、编写处理注解的处理器

　　上面简要地介绍了注解的定义声明与使用方式，注解在后台需要一个处理器才能起作用，所以还得针对上面的注解编写处理器，在这里我们使用Filter作为注解的处理器，编写一个AnnotationHandleFilter，代码如下：

1  1 package me.gacl.web.filter;
2  2 
3  3 import java.io.IOException;
4  4 import java.lang.reflect.InvocationTargetException;
5  5 import java.lang.reflect.Method;
6  6 import java.lang.reflect.Modifier;
7  7 import java.util.HashMap;
8  8 import java.util.Map;
9  9 import java.util.Set;
10 10 import javax.servlet.Filter;
11 11 import javax.servlet.FilterChain;
12 12 import javax.servlet.FilterConfig;
13 13 import javax.servlet.ServletContext;
14 14 import javax.servlet.ServletException;
15 15 import javax.servlet.ServletRequest;
16 16 import javax.servlet.ServletResponse;
17 17 import javax.servlet.http.HttpServletRequest;
18 18 import javax.servlet.http.HttpServletResponse;
19 19 import me.gacl.annotation.WebInitParam;
20 20 import me.gacl.annotation.WebServlet;
21 21 import me.gacl.util.ScanClassUtil;
22 22 
23 23 /**
24 24 * @ClassName: AnnotationHandleFilter
25 25 * @Description: 使用Filter作为注解的处理器
26 26 * @author: 孤傲苍狼
27 27 * @date: 2014-11-12 下午10:15:19
28 28 *
29 29 */ 
30 30 public class AnnotationHandleFilter implements Filter {
31 31 
32 32     private ServletContext servletContext = null;
33 33     
34 34     /* 过滤器初始化时扫描指定的包下面使用了WebServlet注解的那些类
35 35      * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
36 36      */
37 37     public void init(FilterConfig filterConfig) throws ServletException {
38 38         System.out.println("---AnnotationHandleFilter过滤器初始化开始---");
39 39         servletContext = filterConfig.getServletContext();
40 40         Map<String, Class<?>> classMap = new HashMap<String, Class<?>>();
41 41         //获取web.xml中配置的要扫描的包
42 42         String basePackage = filterConfig.getInitParameter("basePackage");
43 43         //如果配置了多个包，例如：<param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
44 44         if (basePackage.indexOf(",")>0) {
45 45             //按逗号进行分隔
46 46             String[] packageNameArr = basePackage.split(",");
47 47             for (String packageName : packageNameArr) {
48 48                 addServletClassToServletContext(packageName,classMap);
49 49             }
50 50         }else {
51 51             addServletClassToServletContext(basePackage,classMap);
52 52         }
53 53         System.out.println("----AnnotationHandleFilter过滤器初始化结束---");
54 54     }
55 55     
56 56     /**
57 57     * @Method: addServletClassToServletContext
58 58     * @Description:添加ServletClass到ServletContext中
59 59     * @Anthor:孤傲苍狼
60 60     *
61 61     * @param packageName
62 62     * @param classMap
63 63     */ 
64 64     private void addServletClassToServletContext(String packageName,Map<String, Class<?>> classMap){
65 65         Set<Class<?>> setClasses =  ScanClassUtil.getClasses(packageName);
66 66         for (Class<?> clazz :setClasses) {
67 67             if (clazz.isAnnotationPresent(WebServlet.class)) {
68 68                 //获取WebServlet这个Annotation的实例
69 69                 WebServlet annotationInstance = clazz.getAnnotation(WebServlet.class);
70 70                 //获取Annotation的实例的value属性的值
71 71                 String annotationAttrValue = annotationInstance.value();
72 72                 if (!annotationAttrValue.equals("")) {
73 73                     classMap.put(annotationAttrValue, clazz);
74 74                 }
75 75                 //获取Annotation的实例的urlPatterns属性的值
76 76                 String[] urlPatterns = annotationInstance.urlPatterns();
77 77                 for (String urlPattern : urlPatterns) {
78 78                     classMap.put(urlPattern, clazz);
79 79                 }
80 80                 servletContext.setAttribute("servletClassMap", classMap);
81 81                 System.out.println("annotationAttrValue："+annotationAttrValue);
82 82                 String targetClassName = annotationAttrValue.substring(annotationAttrValue.lastIndexOf("/")+1);
83 83                 System.out.println("targetClassName："+targetClassName);
84 84                 System.out.println(clazz);
85 85             }
86 86         }
87 87     }
88 88 
89 89     public void doFilter(ServletRequest request, ServletResponse response,
90 90             FilterChain chain) throws IOException, ServletException {
91 91         System.out.println("---进入注解处理过滤器---");
92 92         //将ServletRequest强制转换成HttpServletRequest
93 93         HttpServletRequest req = (HttpServletRequest)request;
94 94         HttpServletResponse res = (HttpServletResponse)response;
95 95         Map<String, Class<?>> classMap = (Map<String, Class<?>>) servletContext.getAttribute("servletClassMap");
96 96         //获取contextPath
97 97         String contextPath = req.getContextPath();
98 98         //获取用户请求的URI资源
99 99         String uri = req.getRequestURI();
100100         //如果没有指明要调用Servlet类中的哪个方法
101101         if (uri.indexOf("!")==-1) {
102102             //获取用户使用的请求方式
103103             String reqMethod = req.getMethod();
104104             //获取要请求的servlet路径
105105             String requestServletName = uri.substring(contextPath.length(),uri.lastIndexOf("."));
106106             //获取要使用的类
107107             Class<?> clazz = classMap.get(requestServletName);
108108             //创建类的实例
109109             Object obj = null;
110110             try {
111111                 obj = clazz.newInstance();
112112             } catch (InstantiationException e1) {
113113                 e1.printStackTrace();
114114             } catch (IllegalAccessException e1) {
115115                 e1.printStackTrace();
116116             }
117117             Method targetMethod = null;
118118             if (reqMethod.equalsIgnoreCase("get")) {
119119                 try {
120120                      targetMethod = clazz.getDeclaredMethod("doGet",HttpServletRequest.class,HttpServletResponse.class);
121121                 } catch (SecurityException e) {
122122                     e.printStackTrace();
123123                 } catch (NoSuchMethodException e) {
124124                     e.printStackTrace();
125125                 }
126126             }else {
127127                 try {
128128                     targetMethod = clazz.getDeclaredMethod("doPost",HttpServletRequest.class,HttpServletResponse.class);
129129                 } catch (SecurityException e) {
130130                     e.printStackTrace();
131131                 } catch (NoSuchMethodException e) {
132132                     e.printStackTrace();
133133                 }
134134             }
135135             
136136             try {
137137                 //调用对象的方法进行处理
138138                 targetMethod.invoke(obj,req,res);
139139             } catch (IllegalArgumentException e) {
140140                 e.printStackTrace();
141141             } catch (IllegalAccessException e) {
142142                 e.printStackTrace();
143143             } catch (InvocationTargetException e) {
144144                 e.printStackTrace();
145145             }
146146         }else {
147147             //获取要请求的servlet路径
148148             String requestServletName = uri.substring(contextPath.length(),uri.lastIndexOf("!"));
149149             //获取要调用的servlet的方法
150150             String invokeMethodName = uri.substring(uri.lastIndexOf("!")+1,uri.lastIndexOf("."));
151151         
152152             //获取要使用的类
153153             Class<?> clazz = classMap.get(requestServletName);
154154             //创建类的实例
155155             Object obj = null;
156156             try {
157157                 obj = clazz.newInstance();
158158             } catch (InstantiationException e1) {
159159                 e1.printStackTrace();
160160             } catch (IllegalAccessException e1) {
161161                 e1.printStackTrace();
162162             }
163163             //获得clazz类定义的所有方法
164164             Method[] methods = clazz.getDeclaredMethods();
165165             //获取WebServlet这个Annotation的实例
166166             WebServlet annotationInstance = clazz.getAnnotation(WebServlet.class);
167167             //获取注解上配置的初始化参数数组
168168             WebInitParam[] initParamArr = annotationInstance.initParams();
169169             Map<String, String> initParamMap = new HashMap<String, String>();
170170             for (WebInitParam initParam : initParamArr) {
171171                 initParamMap.put(initParam.paramName(), initParam.paramValue());
172172             }
173173             //遍历clazz类中的方法
174174             for (Method method : methods) {
175175                 //该方法的返回类型
176176                 Class<?> retType = method.getReturnType();
177177                 //获得方法名
178178                 String methodName = method.getName();
179179                 //打印方法修饰符
180180                 System.out.print(Modifier.toString(method.getModifiers()));
181181                 System.out.print(" "+retType.getName() + " " + methodName +"(");
182182                 //获得一个方法参数数组（getparameterTypes用于返回一个描述参数类型的Class对象数组）
183183                 Class<?>[] paramTypes = method.getParameterTypes();
184184                 for(int j = 0 ; j < paramTypes.length ; j++){
185185                      //如果有多个参数，中间则用逗号隔开，否则直接打印参数
186186                     if (j > 0){
187187                         System.out.print(",");
188188                     }  
189189                     System.out.print(paramTypes[j].getName());
190190                 }
191191                 System.out.println(");");
192192                 if (method.getName().equalsIgnoreCase("init")) {
193193                     try {
194194                         //调用Servlet的初始化方法
195195                         method.invoke(obj, initParamMap);
196196                     } catch (IllegalArgumentException e) {
197197                         e.printStackTrace();
198198                     } catch (IllegalAccessException e) {
199199                         e.printStackTrace();
200200                     } catch (InvocationTargetException e) {
201201                         e.printStackTrace();
202202                     }
203203                 }
204204             }
205205             //获取WebServlet这个Annotation的实例
206206             System.out.println("invokeMethodName："+invokeMethodName);
207207             try {
208208                 try {
209209                     //利用反射获取方法实例，方法的签名必须符合：
210210                     //public void 方法名(HttpServletRequest request, HttpServletResponse response)
211211                     //例如：public void loginHandle(HttpServletRequest request, HttpServletResponse response)
212212                     Method targetMethod = clazz.getDeclaredMethod(invokeMethodName,HttpServletRequest.class,HttpServletResponse.class);
213213                     //调用对象的方法进行处理
214214                     targetMethod.invoke(obj,req,res);
215215                 } catch (SecurityException e) {
216216                     e.printStackTrace();
217217                 } catch (NoSuchMethodException e) {
218218                     e.printStackTrace();
219219                 } catch (IllegalArgumentException e) {
220220                     e.printStackTrace();
221221                 } catch (InvocationTargetException e) {
222222                     e.printStackTrace();
223223                 } 
224224             } catch (IllegalAccessException e) {
225225                 e.printStackTrace();
226226             }
227227         }
228228     }
229229 
230230     public void destroy() {
231231 
232232     }
233233 }

　　AnnotationHandleFilter过滤器初始化时扫描指定的包下面使用了WebServlet注解的那些类，然后将类存储到一个Map集合中，再将Map集合存储到servletContext对象中。

　　在web.xml文件中配置AnnotationHandleFilter过滤器和需要扫描的包

1 1     <filter>
2 2         <description>注解处理过滤器</description>
3 3         <filter-name>AnnotationHandleFilter</filter-name>
4 4         <filter-class>me.gacl.web.filter.AnnotationHandleFilter</filter-class>
5 5         <init-param>
6 6             <description>配置要扫描包及其子包, 如果有多个包,以逗号分隔</description>
7 7             <param-name>basePackage</param-name>
8 8             <param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
9 9             <!-- <param-value>me.gacl.web.controller</param-value> -->
1010         </init-param>
1111     </filter>
1212     
1313     <filter-mapping>
1414         <filter-name>AnnotationHandleFilter</filter-name>
1515         <!-- 拦截后缀是.do的请求 -->
1616         <url-pattern>*.do</url-pattern>
1717     </filter-mapping>

　　AnnotationHandleFilter过滤器初始化方法init(FilterConfig filterConfig)使用到了一个用于扫描某个包下面的类的工具类ScanClassUtil，ScanClassUtil的代码如下：

1  1 package me.gacl.util;
2  2 
3  3 import java.io.File;
4  4 import java.io.FileFilter;
5  5 import java.io.IOException;
6  6 import java.net.JarURLConnection;
7  7 import java.net.URL;
8  8 import java.net.URLDecoder;
9  9 import java.util.Enumeration;
10 10 import java.util.LinkedHashSet;
11 11 import java.util.Set;
12 12 import java.util.jar.JarEntry;
13 13 import java.util.jar.JarFile;
14 14 
15 15 public class ScanClassUtil {
16 16 
17 17     /**
18 18      * 从包package中获取所有的Class
19 19      * 
20 20      * @param pack
21 21      * @return
22 22      */
23 23     public static Set<Class<?>> getClasses(String pack) {
24 24 
25 25         // 第一个class类的集合
26 26         Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
27 27         // 是否循环迭代
28 28         boolean recursive = true;
29 29         // 获取包的名字 并进行替换
30 30         String packageName = pack;
31 31         String packageDirName = packageName.replace('.', '/');
32 32         // 定义一个枚举的集合 并进行循环来处理这个目录下的things
33 33         Enumeration<URL> dirs;
34 34         try {
35 35             dirs = Thread.currentThread().getContextClassLoader().getResources(
36 36                     packageDirName);
37 37             // 循环迭代下去
38 38             while (dirs.hasMoreElements()) {
39 39                 // 获取下一个元素
40 40                 URL url = dirs.nextElement();
41 41                 // 得到协议的名称
42 42                 String protocol = url.getProtocol();
43 43                 // 如果是以文件的形式保存在服务器上
44 44                 if ("file".equals(protocol)) {
45 45                     System.err.println("file类型的扫描");
46 46                     // 获取包的物理路径
47 47                     String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
48 48                     // 以文件的方式扫描整个包下的文件 并添加到集合中
49 49                     findAndAddClassesInPackageByFile(packageName, filePath,
50 50                             recursive, classes);
51 51                 } else if ("jar".equals(protocol)) {
52 52                     // 如果是jar包文件
53 53                     // 定义一个JarFile
54 54                     System.err.println("jar类型的扫描");
55 55                     JarFile jar;
56 56                     try {
57 57                         // 获取jar
58 58                         jar = ((JarURLConnection) url.openConnection())
59 59                                 .getJarFile();
60 60                         // 从此jar包 得到一个枚举类
61 61                         Enumeration<JarEntry> entries = jar.entries();
62 62                         // 同样的进行循环迭代
63 63                         while (entries.hasMoreElements()) {
64 64                             // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
65 65                             JarEntry entry = entries.nextElement();
66 66                             String name = entry.getName();
67 67                             // 如果是以/开头的
68 68                             if (name.charAt(0) == '/') {
69 69                                 // 获取后面的字符串
70 70                                 name = name.substring(1);
71 71                             }
72 72                             // 如果前半部分和定义的包名相同
73 73                             if (name.startsWith(packageDirName)) {
74 74                                 int idx = name.lastIndexOf('/');
75 75                                 // 如果以"/"结尾 是一个包
76 76                                 if (idx != -1) {
77 77                                     // 获取包名 把"/"替换成"."
78 78                                     packageName = name.substring(0, idx)
79 79                                             .replace('/', '.');
80 80                                 }
81 81                                 // 如果可以迭代下去 并且是一个包
82 82                                 if ((idx != -1) || recursive) {
83 83                                     // 如果是一个.class文件 而且不是目录
84 84                                     if (name.endsWith(".class")
85 85                                             && !entry.isDirectory()) {
86 86                                         // 去掉后面的".class" 获取真正的类名
87 87                                         String className = name.substring(
88 88                                                 packageName.length() + 1, name
89 89                                                         .length() - 6);
90 90                                         try {
91 91                                             // 添加到classes
92 92                                             classes.add(Class
93 93                                                     .forName(packageName + '.'
94 94                                                             + className));
95 95                                         } catch (ClassNotFoundException e) {
96 96                                             // log
97 97                                             // .error("添加用户自定义视图类错误 找不到此类的.class文件");
98 98                                             e.printStackTrace();
99 99                                         }
100100                                     }
101101                                 }
102102                             }
103103                         }
104104                     } catch (IOException e) {
105105                         // log.error("在扫描用户定义视图时从jar包获取文件出错");
106106                         e.printStackTrace();
107107                     }
108108                 }
109109             }
110110         } catch (IOException e) {
111111             e.printStackTrace();
112112         }
113113 
114114         return classes;
115115     }
116116     
117117     /**
118118      * 以文件的形式来获取包下的所有Class
119119      * 
120120      * @param packageName
121121      * @param packagePath
122122      * @param recursive
123123      * @param classes
124124      */
125125     public static void findAndAddClassesInPackageByFile(String packageName,
126126             String packagePath, final boolean recursive, Set<Class<?>> classes) {
127127         // 获取此包的目录 建立一个File
128128         File dir = new File(packagePath);
129129         // 如果不存在或者 也不是目录就直接返回
130130         if (!dir.exists() || !dir.isDirectory()) {
131131             // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
132132             return;
133133         }
134134         // 如果存在 就获取包下的所有文件 包括目录
135135         File[] dirfiles = dir.listFiles(new FileFilter() {
136136             // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
137137             public boolean accept(File file) {
138138                 return (recursive && file.isDirectory())
139139                         || (file.getName().endsWith(".class"));
140140             }
141141         });
142142         // 循环所有文件
143143         for (File file : dirfiles) {
144144             // 如果是目录 则继续扫描
145145             if (file.isDirectory()) {
146146                 findAndAddClassesInPackageByFile(packageName + "."
147147                         + file.getName(), file.getAbsolutePath(), recursive,
148148                         classes);
149149             } else {
150150                 // 如果是java类文件 去掉后面的.class 只留下类名
151151                 String className = file.getName().substring(0,
152152                         file.getName().length() - 6);
153153                 try {
154154                     // 添加到集合中去
155155                     //classes.add(Class.forName(packageName + '.' + className));
156156                      //经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
157157                     classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));  
158158                     } catch (ClassNotFoundException e) {
159159                     // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
160160                     e.printStackTrace();
161161                 }
162162             }
163163         }
164164     }
165165 }

　　经过以上两步，我们的自定义注解和针对注解的处理器都开发好了。

2.3、WebServlet注解简单测试

　　编写一个用于跳转到Login.jsp页面的LoginUIServlet，LoginUIServlet就是一个普通的java类，不是一个真正的Servlet，然后使用WebServlet注解标注LoginUIServlet类，代码如下：

1 1 package me.gacl.web.UI;
2 2 
3 3 import java.io.IOException;
4 4 import javax.servlet.ServletException;
5 5 import javax.servlet.http.HttpServletRequest;
6 6 import javax.servlet.http.HttpServletResponse;
7 7 import me.gacl.annotation.WebServlet;
8 8 
9 9 @WebServlet("/servlet/LoginUI")
1010 public class LoginUIServlet {
1111 
1212     public void doGet(HttpServletRequest request, HttpServletResponse response)
1313             throws ServletException, IOException{
1414         request.getRequestDispatcher("/Login.jsp").forward(request, response);
1515     }
1616     
1717     public void doPost(HttpServletRequest request, HttpServletResponse response)
1818             throws ServletException, IOException {
1919         doGet(request, response);
2020     }
2121 }

　　在浏览器中输入访问地址：http://gacl-pc:8080/AnnotationConfigServlet/servlet/Login.do，根据web.xml文件的配置，所有后缀名为 .do请求，都会经过AnnotationHandleFilter过滤器的doFilter方法，在doFilter方法的实现代码中，从HttpServletRequest请求对象中得到请求的方式类型(GET/POST)和请求的URI 。如有请求http://gacl-pc:8080/AnnotationConfigServlet/servlet/LoginUI.do，此时请求方法类型为GET， URI 值为/AnnotationConfigServlet/servlet/LoginUI.do。从ServletConext对象中获取到在过滤器中保存的Map结构，根据 URI 获得一个 Key=”/servlet/LoginUI” ，从 Map 结构中根据此Key得到Value ，此时Value就是要请求调用的那个Servlet类，根据Servlet类创建对象实例，再根据前面得到的请求方法类型，能决定调用此Servlet对象实例的 doGet 或 doPost 方法。最终客户端发生的后缀为.do请求，经由AnnotationHandleFilter对请求对象(HttpServletRequest)的分析，从而调用相应某Servlet的doGet或doPost方法，完成了一次客户端请求到服务器响应的过程。

　　使用注解后程序流程如下所示：

　　运行结果如下：

　　从运行结果中可以看到，我们的注解处理器成功调用了目标Servlet处理用户的请求，通过@WebServlet注解， Servlet不用再在web.xml 文件中进行繁冗的注册，这就是使用@WebServlet注解的方便之处。

2.3、WebServlet注解复杂测试

　　编写Login.jsp页面，代码如下：

1 1 <%@ page language="java" pageEncoding="UTF-8"%>
2 2 <!DOCTYPE HTML>
3 3 <html>
4 4   <head>
5 5     <title>登录页面</title>
6 6   </head>
7 7   
8 8   <body>
9 9     <fieldset>
1010         <legend>用户登录</legend>
1111         <form action="${pageContext.request.contextPath}/servlet/LoginServlet!loginHandle.do" method="post">
1212             用户名：<input type="text" value="${param.usename}" name="usename">
1313             <br/>
1414             密码：<input type="text" value="${param.pwd}" name="pwd">
1515             <br/>
1616             <input type="submit" value="登录"/>
1717         </form>
1818     </fieldset>
1919     <hr/>
2020     <label style="color: red;">${msg}</label>
2121   </body>
2222 </html>

　　form表单中的action属性的URL="${pageContext.request.contextPath}/servlet/LoginServlet!loginHandle.do"，/servlet/LoginServlet表示要访问的是LoginServlet，!后面的loginHandle表示要调用LoginServlet中的****loginHandle方法处理此次的请求，也就是说，我们在访问Servlet时，可以在URL中指明要访问Servlet的哪个方法，AnnotationHandleFilter过滤器的doFilter方法在拦截到用户的请求之后，首先获取用户要访问的URI，根据URI判断用户要访问的Servlet，然后再判断URI中是否包含了"!"，如果有，那么就说明用户显示指明了要访问Servlet的哪个方法，遍历Servlet类中定义的所有方法，如果找到了URI中的那个方法，那么就调用对应的方法处理用户请求！

LoginServlet的代码如下：

1 1 package me.gacl.web.controller;
2 2 
3 3 import java.io.IOException;
4 4 import java.util.Map;
5 5 import javax.servlet.ServletException;
6 6 import javax.servlet.http.HttpServletRequest;
7 7 import javax.servlet.http.HttpServletResponse;
8 8 import me.gacl.annotation.WebInitParam;
9 9 import me.gacl.annotation.WebServlet;
1010 
1111 /**
1212 * 
1313 * @ClassName: LoginServlet
1414 * @Description:处理用户登录的Servlet，
1515 * LoginServlet现在就是一个普通的java类，不是一个真正的Servlet
1616 * @author: 孤傲苍狼
1717 * @date: 2014-10-8 上午12:07:58
1818 *
1919 */
2020 //将开发好的WebServlet注解标注到LoginServlet类上
2121 @WebServlet(
2222             //Servlet的访问URL
2323             value="/servlet/LoginServlet",
2424             //Servlet的访问URL，可以使用数组的方式配置多个访问路径
2525             urlPatterns={"/gacl/LoginServlet","/xdp/LoginServlet"},
2626             //Servlet的初始化参数
2727             initParams={
2828                     @WebInitParam(paramName="gacl",paramValue="孤傲苍狼"),
2929                     @WebInitParam(paramName="bhsh",paramValue="白虎神皇")
3030             },
3131             name="LoginServlet",
3232             description="处理用户登录的Servlet"
3333         )
3434 public class LoginServlet {
3535 
3636     public void loginHandle(HttpServletRequest request, HttpServletResponse response) 
3737             throws ServletException, IOException{
3838         String username = request.getParameter("usename");
3939         String pwd = request.getParameter("pwd");
4040         if (username.equals("gacl") && pwd.equals("xdp")) {
4141             request.getSession().setAttribute("usename", username);
4242             request.setAttribute("msg", "欢迎您！"+username);
4343             request.getRequestDispatcher("/index.jsp").forward(request, response);
4444         }else {
4545             request.setAttribute("msg", "登录失败，请检查用户名和密码是否正确！");
4646             request.getRequestDispatcher("/Login.jsp").forward(request, response);
4747         }
4848     }
4949     
5050     
5151     /**
5252     * @Method: init
5353     * @Description: Servlet初始化
5454     * @Anthor:孤傲苍狼
5555     *
5656     * @param config
5757     */ 
5858     public void init(Map<String, String> initParamMap){
5959         System.out.println("--LoginServlet初始化--");
6060         System.out.println(initParamMap.get("gacl"));
6161         System.out.println(initParamMap.get("bhsh"));
6262     }
6363 }