SpringMVC请求分发的简单实现
简介
以前用了下SpringMVC感觉挺不错了，前段事件也简单了写了一些代码来实现了SpringMVC简单的请求分发功能，实现的主要思想如下：
- 将处理请求的类在系统启动的时候加载起来，相当于SpringMVC中的Controller
- 读取Controller中的配置并对应其处理的URL
- 通过调度Servlet进行拦截请求，并找到相应的Controller进行处理
主要代码
首先得标识出来哪些类是Controller类，这里我自己定义的是ServletHandler，通过Annotation的方式进行标识，并配置每个类和方法处理的URL：
package com.meet58.base.servlet.annotation;
public @interface ServletHandler {
}
这里注解主要是声明这个类是一个ServletHandler类，用于处理请求的类，系统启动的时候就会加载这些类。
package com.meet58.base.servlet.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.meet58.base.servlet.types.RequestMethod;
import com.meet58.base.servlet.types.ResponseType;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface HandlerMapping {
String value();
}
这个注解是配置处理请求的注解，定义了要处理的路径。
定义了注解之后就是要在系统启动的时候扫描并加载这些类，下面是如何进行扫描的代码：
package com.meet58.base.servlet.mapping;
import java.io.IOException;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.ClassUtils;
import com.meet58.base.servlet.annotation.ServletHandler;
public class ServletHandlerMappingResolver {
private static final String RESOURCE_PATTERN = "/**/*.class";
private String[] packagesToScan;
private ResourcePatternResolver resourcePatternResolver;
private static final TypeFilter[] ENTITY_TYPE_FILTERS = new TypeFilter[] {
new AnnotationTypeFilter(ServletHandler.class, false)};
public ServletHandlerMappingResolver(){
this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(new PathMatchingResourcePatternResolver());
}
public ServletHandlerMappingResolver scanPackages(String[] packagesToScan){
try {
for (String pkg : packagesToScan) {
String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
ClassUtils.convertClassNameToResourcePath(pkg) + RESOURCE_PATTERN;
Resource[] resources;
resources = this.resourcePatternResolver.getResources(pattern);
MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader reader = readerFactory.getMetadataReader(resource);
String className = reader.getClassMetadata().getClassName();
if (matchesFilter(reader, readerFactory)) {
ServletHandlerMappingFactory.addClassMapping(this.resourcePatternResolver.getClassLoader().loadClass(className));
}
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return this;
}
public String[] getPackagesToScan() {
return packagesToScan;
}
public void setPackagesToScan(String[] packagesToScan) {
this.packagesToScan = packagesToScan;
this.scanPackages(packagesToScan);
}
private boolean matchesFilter(MetadataReader reader, MetadataReaderFactory readerFactory) throws IOException {
for (TypeFilter filter : ENTITY_TYPE_FILTERS) {
if (filter.match(reader, readerFactory)) {
return true;
}
}
return false;
}
}
这段代码是Spring中如何扫描Hibernate持久化对象的代码，拿过来借鉴了一下，下面要处理的就是把要处理的URL和相对应的ServletHandler进行匹配：
package com.meet58.base.servlet.mapping;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
import com.meet58.base.servlet.annotation.HandlerMapping;
import com.meet58.base.servlet.context.ServletHandlerFactory;
public class ServletHandlerMappingFactory {
private static Logger logger = Logger.getLogger(ServletHandlerMappingFactory.class);
private static Map<String, Method> servletHandlerMapping = new HashMap<String, Method>();
public static void addClassMapping(Class<?> clazz) {
String url = null;
HandlerMapping handlerMapping = clazz.getAnnotation(HandlerMapping.class);
if (handlerMapping != null) {
url = handlerMapping.value();
} else {
String classSimpleName = clazz.getSimpleName().toLowerCase();
url = "/" + classSimpleName.substring(0,
classSimpleName.indexOf("servlet"));
}
if (url != null) {
if(url.endsWith("/")){
url = url.substring(url.length() - 1);
}
ServletHandlerFactory.put(clazz);
logger.info(" Load servlet handler class:" + clazz.getName() + " url:" + url);
scanHandlerMethod(clazz,url);
}
}
public static void scanHandlerMethod(Class<?> clazz,String classMapping) {
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
HandlerMapping handlerMapping = method.getAnnotation(HandlerMapping.class);
if (handlerMapping != null && handlerMapping.value() != null) {
String mapping = handlerMapping.value();
if(!mapping.startsWith("/")){
mapping = "/" + mapping;
}
mapping = classMapping + mapping;
addMethodMapping( mapping,method);
}
}
}
public static void addMethodMapping(String url,Method method) {
logger.info(" Load servlet handler mapping, method:" + method.getName() + " for url:" + url);
Method handlerMethod = servletHandlerMapping.get(url);
if(handlerMethod != null){
throw new IllegalArgumentException(" url :" + url + " is already mapped by :" + handlerMethod);
}else{
servletHandlerMapping.put(url, method);
}
}
public static Method getMethodMapping(String url) {
return servletHandlerMapping.get(url);
}
}
在这个类中扫描了每个ServletHandler类中的方法，并记录他们的要处理的URL，接下来就是通过容器实例化这些ServletHandler类了：
package com.meet58.base.servlet.context;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
public class ServletHandlerFactory {
private static Logger logger = Logger.getLogger(ServletHandlerFactory.class);
private static Map<String,Object> classes = new HashMap<String,Object>();
public static void put(Class<?> clazz){
try {
logger.info("初始化ServletHandler类:"+ clazz.getName());
Object servlet = clazz.newInstance();
classes.put(clazz.getName(), servlet);
} catch (InstantiationException e) {
logger.error("初始化Servlet类:" + clazz.getName() + "失败:" + e.getMessage());
} catch (IllegalAccessException e) {
logger.error("初始化Servlet类:" + clazz.getName() + "失败:" + e.getMessage());
}
}
@SuppressWarnings("unchecked")
public static <T> T get(String className){
return (T)classes.get(className);
}
}
在ServletHandler类处理完成，并知道他们分别处理哪些URL之后，就可以通过一个调度器进行对对应的URL进行请求的分发了：
package com.meet58.base.servlet;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.log4j.Logger;
import com.meet58.base.context.WebHttpRequestContext;
import com.meet58.base.servlet.context.ServletHandlerFactory;
import com.meet58.base.servlet.mapping.ServletHandlerMappingFactory;
import com.meet58.util.WebUtils;
@WebServlet(urlPatterns = { "*.do" })
public class WebHttpDispatchServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private Logger logger = Logger.getLogger(this.getClass());
private List<String> excludeUrls = new ArrayList<String>();
@Override
public void init() throws ServletException {
// 屏蔽websocket地址
excludeUrls.add("/meet.do");
super.init();
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
this.doPost(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
try {
String url = request.getRequestURI().replace(
request.getContextPath(), "");
if (excludeUrls.contains(url)) {
return;
}
Method handlerMethod = ServletHandlerMappingFactory.getMethodMapping(url);
if (handlerMethod == null) {
response.sendError(404, "No handler found for " + url);
logger.error("No handler found for " + url);
return;
}
Object servlet = ServletHandlerFactory.get(handlerMethod
.getDeclaringClass().getName());
if (servlet == null) {
response.sendError(404, "No handler class found for " + url);
logger.error("No handler class found for " + url);
return;
}
Object result = invokeHandlerMethod(servlet, handlerMethod);
handleInvokeResult(result);
// this.doService();
} catch (Throwable e) {
handlerException(e);
}
}
public void handleInvokeResult(Object result) {
String location = "";
if (result instanceof String) {
if (((String) result).startsWith("redirect:")) {
location = ((String) result).substring("redirect:".length(),
((String) result).length());
WebUtils.redirect(location);
} else if (((String) result).startsWith("forward:")) {
location = ((String) result).substring("forward:".length(),
((String) result).length());
WebUtils.forward(location);
}
}
}
public Object invokeHandlerMethod(Object object, Method method)
throws Throwable {
Object result = null;
if (method != null) {
try {
result = method.invoke(object);
} catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
return result;
}
public void handlerException(Throwable e) {
String message = e.getMessage() != null ? e.getMessage() : e.toString();
e.printStackTrace();
if (WebHttpRequestContext.isAsyncRequest()) {
WebUtils.writeFailure(message);
} else {
try {
WebHttpRequestContext.getResponse().sendError(500, message);
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
public String getMappingClass(String url) {
return null;
}
}
这段代码中就是通过URL找到对应的处理方法来进行处理，并且捕获异常。
这种方法Struts也是用到了，不过这个只是简单的兴趣研究并没有在实际项目中运用，可能会存在线程安全的问题。
