重复造轮子没有意义，但是通过现已存在的轮子，模仿着思路去实现一套，还是比较cool的。花了三天，终于深夜搞定！收益都在代码里，我干了，您随意！
一、简单思路
简单介绍：
1、所有的请求交给TyDispatcher处理，TyDispatcher主要负责读取配置、分发请求、初始化handlerMapping等功能；
2、根据handlerMapping与请求url，找到对应的处理方法，并由该处理方法处理业务逻辑；
二、建项目
1、新建maven项目
选择webapp结尾的。然后继续创建，创建完成后，有个设置，因为本次项目是基于tomcat的，右击项目properties-->project facets-->Dynamic Web Module
project facets就是指项目特性的意思，如果不选择这个，eclipse会把项目当做是普通的javase项目，那自然也就无法在tomcat等应用服务器上部署。
进去之后设置路径为src/main/webapp，对应maven的工程目录结构。
2、配置tomcat
新建server这种就不多说了，将项目添加到tomcat中，若是添加不了，说明不是web项目，按照上步操作，其他基本没啥问题了。
项目结构如图：
三、代码
1、注解类
模仿着springMVC实现了@TyController、@TyRequestMapping以及@TyRequestParam三个注解。
a、@TyController
package com.ty.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;
/**
* @author Taoyong
* @date 2018年6月6日
* 天下没有难敲的代码！
*/
//只能在类上使用该注解
@Target(ElementType.TYPE)
//表示在运行时使用
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TyController {
String value() default "";
}
b、@TyRequestMapping
package com.ty.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;
/**
* @author Taoyong
* @date 2018年6月6日
* 天下没有难敲的代码！
*/
//该注解只能在方法上使用
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TyRequestMapping {
String value() default "";
}
c、@TyRequestParam
package com.ty.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;
/**
* @author Taoyong
* @date 2018年6月6日
* 天下没有难敲的代码！
*/
//该注解只能在参数上注解
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TyRequestParam {
String value() default "";
}
2、TyDispatcher(初始化相关basePackage下的controller、分发请求、处理客户端请求参数等等)
package com.ty.dispatcher;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.ty.annotation.TyController;
import com.ty.annotation.TyRequestMapping;
import com.ty.annotation.TyRequestParam;
/**
* @author Taoyong
* @date 2018年6月5日
* 天下没有难敲的代码！
* 此类的主要作用为初始化相关配置以及分发请求
* 首先要将此servlet配置在web.xml中，在容器启动的时候，TyDispatcher初始化，并且在整个容器的生命周期中，只会创建一个TyDispatcher实例
* TyDispatcher在web.xml中的配置信息将会包装成ServletConfig类
*/
public class TyDispatcher extends HttpServlet {
private static final long serialVersionUID = 9003485862460547072L;
//自动扫描的basePackage
private Properties property = new Properties();
//保存所有需要自动创建实例对象的类的名字
private List<String> classNameList = new ArrayList<>();
//IOC容器，是一个键值对(数据格式:{"TestController": Object})
public Map<String, Object> ioc = new HashMap<>();
/*
* 用于存放url与method对象映射关系的容器,数据格式为{"/base/TySpringMVCTest": Method}
*/
private Map<String, Method> handlerMappingMap = new HashMap<>();
//用于将请求url与controller实例对象建立映射关系(数据格式:{"": Controller})
public Map<String, Object> controllerContainer = new HashMap<>();
/*
* init方法主要用于初始化相关配置，比如basePackage
*
*/
@Override
public void init(ServletConfig config) throws ServletException {
//配置basePackage，该包下所有的controller全部自动创建实例
initBaseScan(config);
//扫描basePackage下所有应该被实例化的类
scanBasePackage(property.getProperty("scanPackage"));
//根据classNameList中的文件去创建实例对象(即实例化basePackage下的controller)
createInstance(classNameList);
//初始化handlerMapping
initHandlerMapping(ioc);
}
private void initBaseScan(ServletConfig config) {
/*
* servlet会将web.xml中的配置封装成ServletConfig对象。
* 从该对象获取<init-param>所配置的初始化参数
*/
String location = config.getInitParameter("contextConfigLocation");
//通过类加载器去读取该文件中的数据，并封装成流，然后通过property去加载流
InputStream input = this.getClass().getClassLoader().getResourceAsStream(location);
try {
property.load(input);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private void scanBasePackage(String basePackage) {
/*
* 找到basePackage下所有的resource(resource即为图片、声音、文本等等数据)
* 另外需要将com.ty.controller转换成/com/ty/controller/这种相对路径形式
* \.是为了防止转义
*/
URL url = this.getClass().getClassLoader().getResource("/" + basePackage.replaceAll("\.", "/"));
//此时file相当于一个总文件夹
File totalFolder = new File(url.getFile());
/*
* 列出总文件夹下的文件夹以及文件
*/
for(File file: totalFolder.listFiles()) {
if(file.isDirectory()) {
//通过递归去找到最后一层级的文件，其实也就是.class文件(编译后)
scanBasePackage(basePackage + file.getName());
} else {
//要将编译后文件的.class后缀去掉
classNameList.add(basePackage + "." + file.getName().replaceAll(".class", ""));
}
}
}
private void createInstance(List<String> classNameList) {
if(classNameList == null || classNameList.size() == 0) {
return;
}
for(String className: classNameList) {
try {
//根据className获取Class对象，通过反射去实例化对象
Class<?> clazz = Class.forName(className);
//只需要将basePackage下的controller实例化即可
if(clazz.isAnnotationPresent(TyController.class)) {
Object obj = clazz.newInstance();
//这点跟spring容器稍有不同的是就是key值虽为类名，但是首字母并没有小写
ioc.put(clazz.getSimpleName(), obj);
}
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
/*
* controller现已实例化，但是还要对其方法的url(controller上注解的url+方法上的url)与方法对象建立起映射关系
* ioc数据格式:{"TestController": Object}
*/
private void initHandlerMapping(Map<String, Object> ioc) {
if(ioc.isEmpty()) {
return;
}
for(Entry<String, Object> entry: ioc.entrySet()) {
Class<?> clazz = entry.getValue().getClass();
//如果ioc容器中的对象不是controller对象，不进行处理
if(!clazz.isAnnotationPresent(TyController.class)) {
continue;
}
/*
* controller上配置的@TyRequestMapping的值。因为controller类上使用@TyRequestMapping注解
* 是类维度的，所以通过clazz.getAnnotation获取value值
*/
String baseURL = clazz.getAnnotation(TyController.class).value();
//通过clazz获取到该类下所有的方法数组
Method[] methods = clazz.getMethods();
for(Method method: methods) {
//判断Method对象上是否存在@TyRequestMapping的注解，若有，取其value值
if(!method.isAnnotationPresent(TyRequestMapping.class)) {
continue;
}
String methodURL = method.getAnnotation(TyRequestMapping.class).value();
//数据格式:{"/controller/methodURL": Method}
handlerMappingMap.put(baseURL + methodURL, method);
//并且需要将url对应controller的映射关系保存
controllerContainer.put(baseURL + methodURL, entry.getValue());
}
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doPost(req, resp);
}
/*
* 此类用于处理客户端的请求，所有核心的分发逻辑由doPost控制，包括解析客户端请求参数等等
*
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws
ServletException, IOException {
/*
* 根据JDK的说明，若请求url为http://localhost:8080/TySpringMVC/controller/testMethod
* 则requestURL为/TySpringMVC/controller/testMethod。所以应该将项目名去掉
*/
String requestURL = req.getRequestURI();
//contextPath的路径为/TySpringMVC
String contextPath = req.getContextPath();
//requestMappingURL为/controller/testMethod
String requestMappingURL = requestURL.replaceAll(contextPath, "");
Method method = handlerMappingMap.get(requestMappingURL);
if(method == null) {
/*
* 通过Writer.write向与客户端连接的I/O通道写数据。并且这地方注意设置编码，要保证客户端解析编码与
* 代码中编码格式一致。这也是出现乱码的根本原因所在
*/
resp.setCharacterEncoding("UTF-8");
String errorMessage = "404 请求URL不存在！";
resp.getWriter().write(errorMessage);
return;
}
/*
* 获取前端入参，例如url为http://localhost:8080/TySpringMVC/sss?name=ty
* map:{"name": ["ty","s"}
*/
Map<String, String[]> paramMap = req.getParameterMap();
//获取该method的所有参数对象数组。注：这地方找了好久api，才找到此方法。。。
Parameter[] params = method.getParameters();
//用于将前端参数封装，并且供method执行
Object[] paramArr = new Object[params.length];
for(int i = 0; i < params.length; i++) {
//这两个if是用于解决method中的参数类型为HttpServletRequest或HttpServletResponse
if("HttpServletRequest".equals(params[i].getType().getSimpleName())) {
paramArr[i] = req;
continue;
}
if("HttpServletResponse".equals(params[i].getType().getSimpleName())) {
paramArr[i] = resp;
continue;
}
if(params[i].isAnnotationPresent(TyRequestParam.class)) {
String paramKey = params[i].getAnnotation(TyRequestParam.class).value();
//客户端传过来的参数会是[小可爱]这种形式，因此需要去除[以及]，并且需要使用转义符
String value = Arrays.toString(paramMap.get(paramKey)).replaceAll("\[", "").replaceAll("\]", "");
paramArr[i] = value;
}
}
//开始调用反射来执行method
try {
method.invoke(controllerContainer.get(requestMappingURL), paramArr);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void destroy() {
super.destroy();
}
}
3、tySpringMVC.properties(主要用来配置basePackage)
scanPackage=com.ty.controller
4、BaseCntroller(用来测试的controller)
package com.ty.controller;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.ty.annotation.TyController;
import com.ty.annotation.TyRequestMapping;
import com.ty.annotation.TyRequestParam;
/**
* @author Taoyong
* @date 2018年6月7日
* 天下没有难敲的代码！
*/
@TyController("/baseController")
public class BaseController {
@TyRequestMapping("/firstMethod")
public void firstMethod(HttpServletRequest req, HttpServletResponse resp, @TyRequestParam("name") String name) {
try {
resp.setCharacterEncoding("UTF-8");
resp.getWriter().write("我不管，我最帅，我是你们的" + name);
} catch (IOException e) {
e.printStackTrace();
}
}
}
四、测试
1、成功场景(控制层中通过@TyRequestParam注解拿到前台的入参，并打印)
2、请求不存在
当然，水平有限，有什么错误的地方
所有源代码已经上传到github中：https://github.com/ali-mayun/springMVC
