从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();
}
}
}
}
}