以Filter模拟Servlet3的注解方式

从Servlet3.0开始,配置Servlet支持注解方式,但还是保留了配置web.xml方式.
例如:

@WebServlet(
    name = "Annolet", 
    urlPatterns = "/anno", 
    loadOnStartup = 1, 
    initParams = {  
            @WebInitParam(name = "name", value = "小明"),   
            @WebInitParam(name = "pwd", value = "123456") 
    }
)
//@WebServlet("/anno")
public class ServletAnno extends HttpServlet {

接下来我们模拟Servlet3的注解配置,思路如下:
1、定义相关的注解
2、用过滤器作为注解的处理器
3、配置过滤器
4、测试

WebServlet注解的定义

/**
 * 
 */
package servlet3.Annotaion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


/**
 * @author Administrator
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface WebServlet {
    //servlet的访问url
    String value();
    String[] urlPattens() default{""};

    //Servlet的描述
    String desription() default "";

    //Servlet的显示名称
    String displayName() default "";

    //Servletd的名字
    String name() default "";

    //Servlet的init参数
    WebInitParam[] initParams() default {};

}
/**
 * 
 */
package servlet3.Annotaion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author Administrator
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface WebInitParam {
    //参数名
    String paramName() default "";
    //参数值
    String paramValue() default "";
}

用过滤器定义注解处理器

web.xml中配置过滤器

<!-- 过滤器配置 -->
    <filter>
        <description>自定义servlet注解处理器</description>
        <filter-name>AnnotationHandleFilter</filter-name>
        <filter-class>servlet3.AnnotaionTest.AnnotationHandleFilte</filter-class>
        <init-param>
        <description>配置要扫描包及其子包, 如果有多个包,以逗号分隔</description>
            <param-name>basepack</param-name>
            <param-value>servlet3.AnnotaionTest</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>AnnotationHandleFilter</filter-name>
        <url-pattern>*.do</url-pattern>
    </filter-mapping>

将以.do结尾的请求交给该过滤器,过滤器扫描servlet3.AnnotaionTest包下的类,多个包以逗号分隔

注解处理器代码如下:

/**
 * 
 */
package servlet3.AnnotaionTest;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import servlet3.Annotaion.WebServlet;
import util.ScanClassUtil;

/**
 * @ClassNmae AnnotationHandleFilter
 * @Description:使用Filter作为注解的处理器
 * @author Administrator
 *
 */
public class AnnotationHandleFilte implements Filter {
    private ServletContext servletContex = null;

    /**
     * 初始化时扫描项目指定包下面的使用WebService注解的类 将注解的映射地址和类的class对象以键值对的形式放在Map中
     * 然后将map设置为ServletContext的属性,在doFilter时获取
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    System.out.println("========AnnotationHandleFilter处理器初始化开始");
    servletContex = filterConfig.getServletContext();

    Map<String, Class<?>> classMap = new HashMap<String, Class<?>>();

    // 获取web.xml中配置的需要扫描的包
    String basePackage = filterConfig.getInitParameter("basepack");
    // 有,就是多个包分割符
    if (basePackage.indexOf(",") > 0) {
        String[] packageNames = basePackage.split(",");
        for (String packageName : packageNames) {
        addServletClassToServletContex(packageName, classMap);
        }
    } else {
        addServletClassToServletContex(basePackage, classMap);
    }
    }

    /**
     * @Description:添加ServletClass到ServletContext中
     * @param packageName
     * @param classMap
     */
    private void addServletClassToServletContex(String packageName, Map<String, Class<?>> classMap) {
    Set<Class<?>> setclasses = ScanClassUtil.getClasses(packageName);


    for (Class<?> clazz : setclasses) {

        if (clazz.isAnnotationPresent(WebServlet.class)) {
        //System.out.println("==========有WebServlet注解的类");
        Object obj;
        try {
            obj = clazz.newInstance();
            Method initMethod = clazz.getDeclaredMethod("init");
            if (initMethod != null) {
            // 有初始化方法时,先初始化
            initMethod.invoke(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        WebServlet webServletInstance = clazz.getAnnotation(WebServlet.class);
        // 获取注解的value属性
        String annotationAttrValue = webServletInstance.value();
        if (!annotationAttrValue.equals("")) {
            classMap.put(annotationAttrValue, clazz);

        }

        // 获取注解实例的urlPattens属性的值
        String[] urlPatterns = webServletInstance.urlPattens();
        for (String urlpattern : urlPatterns) {
            classMap.put(urlpattern, clazz);
        }

        servletContex.setAttribute("servletClassMap", classMap);

        System.out.println("annotationAttrValue:" + annotationAttrValue);
        String targetClassName = annotationAttrValue.substring(annotationAttrValue.lastIndexOf("/") + 1);
        System.out.println("targetClassName:" + targetClassName);
        System.out.println(clazz);
        }
    }
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
    System.out.println("==========WebServlet注解处理器开始处理=========");
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse res = (HttpServletResponse) response;
    // 取出初始化设置的ServletContext属性
    Map<String, Class<?>> classMap = (Map<String, Class<?>>) servletContex.getAttribute("servletClassMap");

    // 获取contexpath,也就是项目路径,例如http://localhost:8080/servlet的/servlet
    String contextPath = req.getContextPath();

    // 获取类的URI(统一资源标识符),例如http://localhost:8080/servlet/test的/servlet/test
    String uri = req.getRequestURI();

    /*
     * 模拟servlet,没有继承HTTPServlet,所以就不会自己执行doGet和doPost方法 需要自己指定,指定方法为!
     */
    // 如果没有指定调用servlet的哪个方法
    if (uri.indexOf("!") == -1) {
        // 获取用户的请求方式
        String reqMethod = req.getMethod();
        // 获取请求的servlet的路径
        String requestServletName;
        int lastReg = uri.lastIndexOf(".do");
        // 以.do结尾的或者直接就是不带.的uri
        requestServletName = (lastReg != -1) ? uri.substring(contextPath.length(), lastReg)
            : uri.substring(contextPath.length(), uri.length());

        // 获取请求的类的Class对象
        Class<?> clazz = classMap.get(requestServletName);
        if(clazz==null){
        res.sendRedirect("404.jsp");
        return;
        }
        // 创建类的实例
        Object obj = null;
        try {
        obj = clazz.newInstance();
        } catch (InstantiationException e) {
        e.printStackTrace();
        } catch (IllegalAccessException e) {
        e.printStackTrace();
        }
        Method targetMethod = null;
        if (reqMethod.equalsIgnoreCase("get")) {
        try {
            targetMethod = clazz.getDeclaredMethod("doGet", HttpServletRequest.class,
                HttpServletResponse.class);

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        } else {
        try {
            targetMethod = clazz.getDeclaredMethod("doPost", HttpServletRequest.class,
                HttpServletResponse.class);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        }
        // 反射调用对应的doGet或者doPost方法
        try {
        targetMethod.invoke(obj, req, res);
        } catch (IllegalAccessException e) {
        e.printStackTrace();
        } catch (IllegalArgumentException e) {
        e.printStackTrace();
        } catch (InvocationTargetException e) {
        e.printStackTrace();
        }

    } else {
        // 获取要请求的servlet路径
        String requestServletName = uri.substring(contextPath.length(), uri.lastIndexOf("!"));
        // 获取要调用的servlet的方法
        int lastReg = uri.lastIndexOf(".do");
        String invokeMethodName = (lastReg != -1) ? uri.substring(uri.lastIndexOf("!") + 1, lastReg)
            : uri.substring(uri.lastIndexOf("!") + 1, uri.length());

        // 获取要使用的类
        Class<?> clazz = classMap.get(requestServletName);
        if(clazz==null){
        res.sendRedirect("404.jsp");
        return;
        }
        // 创建类的实例
        Object obj = null;
        try {
        obj = clazz.newInstance();
        } catch (InstantiationException e1) {
        e1.printStackTrace();
        } catch (IllegalAccessException e1) {
        e1.printStackTrace();
        }
        try {
        Method methodDo = clazz.getDeclaredMethod(invokeMethodName, HttpServletRequest.class,
            HttpServletResponse.class);
        methodDo.invoke(obj, req, res);

        } catch (NoSuchMethodException e) {
        e.printStackTrace();
         res.sendRedirect("404.jsp");
            return;

        } catch (SecurityException e) {
        e.printStackTrace();
        } catch (IllegalAccessException e) {
        e.printStackTrace();
        } catch (InvocationTargetException e) {
        e.printStackTrace();
        }

    }
    }

    @Override
    public void destroy() {

    }

}

以上代码过长,可能部分同学看的困难,我简单解释一下:
1、过滤器初始化时将带有注解的类的注解定义的虚拟路径和该类的class对象以Map的形式保存在servletContext中,如果该注解类有初始化方法,先初始化
2、注解过滤器进行处理,首先获取请求的路径,根据是否带!来判断是否调用注解类的方法,不带的话默认调用doGet方法,获取servletContext中存储的Map,根据请求的路径来过去对应资源的class对象,没有的话跳转404页面,根据class对象实现对doGet或者请求方法的反射调用,如果没有改方法,同样跳转404

测试

测试类的代码

/**
 * 
 */
package servlet3.AnnotaionTest;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import servlet3.Annotaion.WebServlet;

/**
 * @author Administrator
 *
 */
@WebServlet("/annoServlet")
public class AnnoServelt {
    public void init(){
    System.out.println("Servlet的初始化方法");
    }

    /**
     * @param request
     * @param response
     */
    private void doPost(HttpServletRequest request, HttpServletResponse response) {
    System.out.println("do***处理请求");
    }

    /**
     * 
     * @param request
     * @param response
     */
    public void doGet(HttpServletRequest request,HttpServletResponse response){
    doPost(request,response);
    }

    public void test(HttpServletRequest request,HttpServletResponse response){
    System.out.println("!请求访问@webServlet的方法成功");
    }

}

浏览器输入

127.0.0.1:8080/servlet/annoServlet.do

程序输出

========AnnotationHandleFilter处理器初始化开始
file类型的扫描
Servlet的初始化方法
annotationAttrValue:/annoServlet
targetClassName:annoServlet
class servlet3.AnnotaionTest.AnnoServelt
==========WebServlet注解处理器开始处理=========
do***处理请求

浏览器输入

127.0.0.1:8080/servlet/annoServlet!test.do

程序输出

==========WebServlet注解处理器开始处理=========
!请求访问@webServlet的方法成功

工具类ScanClassUtil.java

/**
 * 
 */
package util;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.net.JarURLConnection;
/**
 * @author Administrator
 *
 */
public class ScanClassUtil {

         /**
          * 从包package中获取所有的Class
          * 
          * @param pack
          * @return
          */
         public static Set<Class<?>> getClasses(String pack) {

             // 第一个class类的集合
             Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
             // 是否循环迭代
             boolean recursive = true;
             // 获取包的名字 并进行替换
             String packageName = pack;
             String packageDirName = packageName.replace('.', '/');
             // 定义一个枚举的集合 并进行循环来处理这个目录下的things
             Enumeration<URL> dirs;
             try {
                 dirs = Thread.currentThread().getContextClassLoader().getResources(
                         packageDirName);
                 // 循环迭代下去
                 while (dirs.hasMoreElements()) {
                     // 获取下一个元素
                     URL url = dirs.nextElement();
                     // 得到协议的名称
                     String protocol = url.getProtocol();
                     // 如果是以文件的形式保存在服务器上
                     if ("file".equals(protocol)) {
                         System.err.println("file类型的扫描");
                        // 获取包的物理路径
                         String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                         // 以文件的方式扫描整个包下的文件 并添加到集合中
                         findAndAddClassesInPackageByFile(packageName, filePath,
                                 recursive, classes);
                     } else if ("jar".equals(protocol)) {
                         // 如果是jar包文件
                         // 定义一个JarFile
                         System.err.println("jar类型的扫描");
                        JarFile jar;
                         try {
                             // 获取jar
                             jar = ((JarURLConnection) url.openConnection()).getJarFile();
                             // 从此jar包 得到一个枚举类
                             Enumeration<JarEntry> entries = jar.entries();
                             // 同样的进行循环迭代
                             while (entries.hasMoreElements()) {
                                 // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                                 JarEntry entry = entries.nextElement();
                                 String name = entry.getName();
                                 // 如果是以/开头的
                                 if (name.charAt(0) == '/') {
                                     // 获取后面的字符串
                                     name = name.substring(1);
                                 }
                                 // 如果前半部分和定义的包名相同
                                 if (name.startsWith(packageDirName)) {
                                     int idx = name.lastIndexOf('/');
                                     // 如果以"/"结尾 是一个包
                                     if (idx != -1) {
                                         // 获取包名 把"/"替换成"."
                                         packageName = name.substring(0, idx)
                                                 .replace('/', '.');
                                     }
                                     // 如果可以迭代下去 并且是一个包
                                     if ((idx != -1) || recursive) {
                                         // 如果是一个.class文件 而且不是目录
                                         if (name.endsWith(".class")
                                                 && !entry.isDirectory()) {
                                           // 去掉后面的".class" 获取真正的类名
                                             String className = name.substring(
                                                     packageName.length() + 1, name
                                                             .length() - 6);
                                             try {
                                                 // 添加到classes
                                                 classes.add(Class
                                                         .forName(packageName + '.'
                                                                 + className));
                                             } catch (ClassNotFoundException e) {
                                                 // log
                                                 // .error("添加用户自定义视图类错误 找不到此类的.class文件");
                                                 e.printStackTrace();
                                             }
                                        }
                                    }
                                }
                            }
                        } catch (IOException e) {
                            // log.error("在扫描用户定义视图时从jar包获取文件出错");
                            e.printStackTrace();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            return classes;
        }

        /**
         * 以文件的形式来获取包下的所有Class
         * 
         * @param packageName
         * @param packagePath
         * @param recursive
         * @param classes
         */
        public static void findAndAddClassesInPackageByFile(String packageName,
                String packagePath, final boolean recursive, Set<Class<?>> classes) {
            // 获取此包的目录 建立一个File
            File dir = new File(packagePath);
            // 如果不存在或者 也不是目录就直接返回
            if (!dir.exists() || !dir.isDirectory()) {
                // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
                return;
            }
            // 如果存在 就获取包下的所有文件 包括目录
            File[] dirfiles = dir.listFiles(new FileFilter() {
                // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
                public boolean accept(File file) {
                    return (recursive && file.isDirectory())
                            || (file.getName().endsWith(".class"));
                }
            });
            // 循环所有文件
            for (File file : dirfiles) {
                // 如果是目录 则继续扫描
                if (file.isDirectory()) {
                    findAndAddClassesInPackageByFile(packageName + "."
                            + file.getName(), file.getAbsolutePath(), recursive,
                            classes);
                } else {
                    // 如果是java类文件 去掉后面的.class 只留下类名
                    String className = file.getName().substring(0,
                            file.getName().length() - 6);
                    try {
                        // 添加到集合中去
                        //classes.add(Class.forName(packageName + '.' + className));
                         //经过回复同学的提醒,这里用forName有一些不好,会触发static方法,没有使用classLoader的load干净
                        classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));  
                        } catch (ClassNotFoundException e) {
                        // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
                        e.printStackTrace();
                    }
                }
            }
        }
   }
点赞

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注