自定义的springMvc框架简单实现
最近通过学习前辈们的自定义的mini版springMvc框架实现案例，自己也模仿着学习了一遍，以此记录下来：
SpringMVC运行流程
执行过程如图所示：
⑴用户发送请求至前端控制器DispatcherServlet。
⑵ DispatcherServlet收到请求调用HandlerMapping处理器映射器。
⑶ 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
⑷ DispatcherServlet通过HandlerAdapter处理器适配器调用处理器。
⑸ 执行处理器(Controller，也叫后端控制器)。
⑹ Controller执行完成返回ModelAndView。
⑺ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
⑻ DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
⑼ ViewReslover解析后返回具体View。
⑽ DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
⑾ DispatcherServlet响应用户。
从上面可以看出，DispatcherServlet有接收请求，响应结果，转发等作用。有了DispatcherServlet之后，可以减少组件之间的耦合度。
另外大家也可以看下我的另一个文章，SpringMVC中的九大组件的理解和源码
不多说直接上代码：
整体工程架构如下图：
这个项目是一个maven项目，下面是具体类的代码：
package com.lyh.annotation;
import java.lang.annotation.*;
/**
* @author 633805 LYH
* @version V1.0
* @description 自动注入的注解
* @create 2018-11-01 8:41
* @since 1.7
*/
@Documented
@Target(ElementType.FIELD)//(字段)标志此注解可以修饰在哪些地方，类，成员变量，方法.
@Retention(RetentionPolicy.RUNTIME)//Annotation的生命周期，一般情况下，我们自定义注解的话，显然需要在运行期获取注解的一些信息。
public @interface MyAutowired {
public String value() default "";
}
package com.lyh.annotation;
import java.lang.annotation.*;
/**
* @author 633805 LYH
* @version V1.0
* @description 控制层的注解
* @create 2018-11-01 8:36
* @since 1.7
*/
@Documented
@Target(ElementType.TYPE)//作用于类上
@Retention(RetentionPolicy.RUNTIME)
public @interface MyController {
public String value() default "";
}
package com.lyh.annotation;
import java.lang.annotation.*;
/**
* @author 633805 LYH
* @version V1.0
* @description @Qualifier提供依赖注入
* @create 2018-11-01 8:52
* @since 1.7
*/
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyQualifier {
public String value();
}
package com.lyh.annotation;
import java.lang.annotation.*;
/**
* @author 633805 LYH
* @version V1.0
* @description 对持久层的注解
* @create 2018-11-01 8:50
* @since 1.7
*/
@Documented//JavaDoc文档
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRepository {
public String value() default "";
}
package com.lyh.annotation;
import java.lang.annotation.*;
/**
* @author 633805 LYH
* @version V1.0
* @description 方法映射的注解
* @create 2018-11-01 8:39
* @since 1.7
*/
@Documented
@Target({ElementType.METHOD,ElementType.TYPE})//作用于类或者方法上
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRequestMapping {
public String value();
}
package com.lyh.annotation;
import java.lang.annotation.*;
/**
* @author 633805 LYH
* @version V1.0
* @description 对于映射参数的注解
* @create 2018-11-01 8:55
* @since 1.7
*/
@Documented
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRequestParam {
public String value();
}
package com.lyh.annotation;
import java.lang.annotation.*;
/**
* @author 633805 LYH
* @version V1.0
* @description Service层的注解
* @create 2018-11-01 8:38
* @since 1.7
*/
@Documented
@Target(ElementType.TYPE)//作用于类上
@Retention(RetentionPolicy.RUNTIME)
public @interface MyService {
public String value() default "";
}
package com.lyh.controller;
import com.lyh.annotation.MyAutowired;
import com.lyh.annotation.MyController;
import com.lyh.annotation.MyRequestMapping;
import com.lyh.annotation.MyRequestParam;
import com.lyh.service.TestService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 633805 LYH
* @version V1.0
* @description 对类的描述
* @create 2018-11-01 14:48
* @since 1.7
*/
@MyController
@MyRequestMapping("test1")
public class TestController1 {
@MyAutowired
private TestService testService;
@MyRequestMapping("test")
public void myTest(HttpServletRequest req, HttpServletResponse resp, @MyRequestParam("param") String param) {
try {
resp.getWriter().write("TestController1: the param you send is :" + param);
testService.printParam(param);
} catch (IOException e) {
e.printStackTrace();
}
}
}
package com.lyh.dao;
/**
* @author 633805 LYH
* @version V1.0
* @description 对类的描述
* @create 2018-10-31 15:56
* @since 1.7
*/
public interface UserDao {
void insert();
}
package com.lyh.dao.impl;
import com.lyh.annotation.MyRepository;
import com.lyh.dao.UserDao;
/**
* @author 633805 LYH
* @version V1.0
* @description 对类的描述
* @create 2018-10-31 15:57
* @since 1.7
*/
@MyRepository("userDaoImpl")
public class UserDaoImpl implements UserDao{
@Override
public void insert() {
System.out.println("execute UserDaoImpl insert()");
}
}
package com.lyh.service;
/**
* @author 633805 LYH
* @version V1.0
* @description 对类的描述
* @create 2018-11-01 14:41
* @since 1.7
*/
public interface TestService {
void printParam(String param);
}
package com.lyh.service.impl;
import com.lyh.annotation.MyAutowired;
import com.lyh.annotation.MyService;
import com.lyh.dao.UserDao;
import com.lyh.service.TestService;
/**
* @author 633805 LYH
* @version V1.0
* @description 对类的描述
* @create 2018-11-01 14:43
* @since 1.7
*/
@MyService
public class TestServiceImpl implements TestService {
@MyAutowired
UserDao userDao;
@Override
public void printParam(String param) {
System.out.println("接收到的参数为：" + param);
userDao.insert();
}
}
package com.lyh.servlet;
import com.lyh.annotation.*;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;
import java.util.logging.Logger;
/**
* @author 633805 LYH
* @version V1.0
* @description MVC框架的请求分转
* @create 2018-11-01 8:58
* @since 1.7
* Remark：继承HttpServlet，重写init方法、doGet、doPost方法
*/
public class MyDispatcherServlet extends HttpServlet {
private Logger logger = Logger.getLogger("init");
private Properties properties = new Properties();
private List<String> classNames = new ArrayList<String>();
private Map<String, Object> ioc = new HashMap<String, Object>();
//handlerMapping的类型可以自定义为Handler
private Map<String, Object> handlerMapping = new HashMap<String, Object>();
private Map<String, Object> controllerMap = new HashMap<String, Object>();
@Override
public void init(ServletConfig config) throws ServletException {
super.init();
logger.info("初始化MyDispatcherServlet");
//1.加载配置文件，填充properties字段
doLoadConfig(config.getInitParameter("contextConfigLocation"));
//2.根据properties，初始化所有相关联的类，扫描用户设定的包下面所有的类
doScanner(properties.getProperty("scanPackage"));
//3.拿到扫描到的类，通过反射的机制，实例化，并且放到ioc容器中（k-v beanName bean）
doInstance();
//4.自动化注入
doAutowired();
//5.初始化HandlerMapping（将url和method对应上）
initHandlerMapping();
doAutowired2();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
//注释掉父类的实现，不然会报错：405 Http method POST is not supported by ...
//super.doPost(req, resp);
logger.info("执行MyDispatcherServlet的doPost()方法");
try {
//处理请求
doDispatch(req, resp);
} catch (Exception e) {
try {
resp.getWriter().write("500!!! Server Exception");
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
//注释掉父类的实现，不然会报错：405 Http method GET is not supported by ...
//super.doGet(req, resp);
logger.info("在执行MyDispatcherServlet的doGet()方法");
try {
//处理请求
doDispatch(req, resp);
} catch (Exception e) {
try {
resp.getWriter().write("500!!! Server Exception");
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
private void doDispatch(HttpServletRequest req, HttpServletResponse resp) {
if (handlerMapping.isEmpty()){
return;
}
String url = req.getRequestURI();
String contextPath = req.getContextPath();
url = url.replace(contextPath, "").replaceAll("/+", "/");
//去掉url前面的斜杆“/”，所有的@Myrequestmapping可以不用写斜杆“/”
if (url.lastIndexOf('/') != 0) {
url = url.substring(1);
}
if (!this.handlerMapping.containsKey(url)) {
try {
resp.getWriter().write("404 NOT FOUND");
logger.info("404 NOT FOUND!");
return;
} catch (IOException e) {
e.printStackTrace();
}
}
Method method = (Method) this.handlerMapping.get(url);
//获取方法的参数列表
Class<?>[] parameterTypes = method.getParameterTypes();
//获取请求的参数
Map<String, String[]> parameterMap = req.getParameterMap();
//保存的参数值
Object[] paramValues = new Object[parameterTypes.length];
//方法的参数列表
for (int i =0, len = parameterTypes.length; i < len; i ++) {
//根据参数名称，做某些处理
String requestParam = parameterTypes[i].getSimpleName();
if ("HttpServletRequest".equals(requestParam)) {
//参数类型已经明确，这边强转类型
paramValues[i] = req;
continue;
}
if ("HttpServletResponse".equals(requestParam)) {
paramValues[i] = resp;
continue;
}
if ("String".equals(requestParam)) {
for (Map.Entry<String, String[]> param : parameterMap.entrySet()) {
String value = Arrays.toString(param.getValue()).replaceAll("\\[|\\]", "").replaceAll(",\\s", ",");
paramValues[i] = value;
}
}
}
//利用反射机制来调用
try {
//第一个参数是method所对应的实例 在ioc容器中
method.invoke(this.controllerMap.get(url),paramValues);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 根据配置文件位置，读取配置文件中的配置信息，将其填充到properties字段
* @param location 配置文件的位置
*/
private void doLoadConfig(String location) {
//将web.xml中的contextConfigLocation对应value值得文件加载到流里面
InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(location);
try {
//用Properties文件加载文件里的内容
logger.info("读取"+location+"里面的文件");
properties.load(resourceAsStream);
} catch (IOException e) {
e.printStackTrace();
} finally {
//关流
if (null != resourceAsStream) {
try {
resourceAsStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 将指定包下扫描得到的类，添加到classNames字段中；
* @param packageName 需要扫描的包名
*
*/
private void doScanner(String packageName) {
URL url =this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/"));
File dir = new File(url.getFile());
for (File file : dir.listFiles()) {
if (file.isDirectory()) {
//递归取包
doScanner(packageName+"."+file.getName());
} else {
String className =packageName +"." +file.getName().replace(".class", "");
classNames.add(className);
}
}
}
/**
* 将classNames中的类实例化，经key-value：类名（小写）-类对象放入ioc字段中
* Params:
*/
private void doInstance() {
if (classNames.isEmpty()) {
return;
}
for (String className : classNames) {
try {
//把类搞出来，反射来实例化（只有加@Controller需要实例化）
Class<?> clazz = Class.forName(className);
if (clazz.isAnnotationPresent(MyController.class)) {
ioc.put(toLowerFirstWord(clazz.getSimpleName()),clazz.newInstance());
} else if (clazz.isAnnotationPresent(MyService.class)){
MyService myService=clazz.getAnnotation(MyService.class);
String beanName=myService.value();
if ("".equals(beanName.trim())) {
beanName = toLowerFirstWord(clazz.getSimpleName());
}
Object instance = clazz.newInstance();
ioc.put(beanName, instance);
Class[] interfaces = clazz.getInterfaces();
for (Class<?> i : interfaces) {
ioc.put(i.getName(), instance);
}
} else if(clazz.isAnnotationPresent(MyRepository.class)) {
MyRepository myRepository=clazz.getAnnotation(MyRepository.class);
String beanName=myRepository.value();
if ("".equals(beanName.trim())) {
beanName = toLowerFirstWord(clazz.getSimpleName());
}
Object instance = clazz.newInstance();
ioc.put(beanName, instance);
Class[] interfaces = clazz.getInterfaces();
for (Class<?> i : interfaces) {
ioc.put(i.getName(), instance);
}
} else {
continue;
}
} catch (Exception e) {
e.printStackTrace();
continue;
}
}
}
/**
* 自动化的依赖注入
*/
private void doAutowired() {
if (ioc.isEmpty()) {
return;
}
for (Map.Entry<String, Object> entry : ioc.entrySet()) {
//包括私有的方法，在spring中没有隐私，@MyAutowired可以注入public、private字段
Field[] fields=entry.getValue().getClass().getDeclaredFields();
for (Field field:fields){
if (!field.isAnnotationPresent(MyAutowired.class)){
continue;
}
MyAutowired autowired= field.getAnnotation(MyAutowired.class);
String beanName=autowired.value().trim();
if ("".equals(beanName)) {
beanName = field.getType().getName();
}
field.setAccessible(true);
try {
field.set(entry.getValue(), ioc.get(beanName));
} catch (Exception e) {
e.printStackTrace();
continue;
}
}
}
}
private void doAutowired2() {
if (controllerMap.isEmpty()) {
return;
}
for (Map.Entry<String,Object> entry : controllerMap.entrySet()) {
//包括私有的方法，在spring中没有隐私，@MyAutowired可以注入public、private字段
Field[] fields=entry.getValue().getClass().getDeclaredFields();
for (Field field:fields){
if (!field.isAnnotationPresent(MyAutowired.class)) {
continue;
}
MyAutowired autowired= field.getAnnotation(MyAutowired.class);
String beanName=autowired.value().trim();
if ("".equals(beanName)) {
beanName = field.getType().getName();
}
field.setAccessible(true);
try {
field.set(entry.getValue(), ioc.get(beanName));
} catch (Exception e) {
e.printStackTrace();
continue;
}
}
}
}
/**
* \初始化HandlerMapping(将url和method对应上)
*/
private void initHandlerMapping() {
if (ioc.isEmpty()) {
return;
}
try {
for (Map.Entry<String, Object> entry : ioc.entrySet()) {
Class<? extends Object> clazz = entry.getValue().getClass();
if(!clazz.isAnnotationPresent(MyController.class)){
continue;
}
//拼接url时，是Controller头的url拼上方法的url
String baseUrl = "";
if (clazz.isAnnotationPresent(MyRequestMapping.class)) {
MyRequestMapping annotation = clazz.getAnnotation(MyRequestMapping.class);
baseUrl = annotation.value();
}
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if (!method.isAnnotationPresent(MyRequestMapping.class)) {
continue;
}
MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class);
String url = annotation.value();
url = (baseUrl + "/" +url).replaceAll("/+", "/");
handlerMapping.put(url, method);
controllerMap.put(url, clazz.newInstance());
System.out.println(url + "," + method);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 将字符串中的首字母小写
* @param name
* @return
*/
private String toLowerFirstWord(String name) {
char[] charArray = name.toCharArray();
charArray[0] += 32;
return String.valueOf(charArray);
}
}
application.properties文件：
scanPackage=com.lyhweb.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<servlet>
<servlet-name>MiniServlet</servlet-name>
<servlet-class>com.lyh.servlet.MyDispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>application.properties</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>MiniServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
pom.xml主要引入的jar包
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
<scope>provided</scope>
</dependency>主要是dispatcherServlet分发管理器类的实现，接下来是使用本地tomcat搭载项目测试：
到此springmvc的简单功能就模拟实现了。。。。