手写自己的springmvc- 2020-12-13 09:40- springmvc: 手写自己的springmvc

springmvc

概念

springmvc属于表现层的框架,它是Spring框架的一部分,我们可以从Spring的整体结构中看得出来：

image.png

处理流程

框架流程

流程图

image.png\

流程解析

1、 用户发送请求至前端控制器DispatcherServlet（配置在web.xml中）
2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器（HandlerMapping处理器映射器存储请求的url和对应的方法之间的映射关系，方法上的注解@ RequestMapping来建立这种映射关系）。
3、 处理器映射器根据请求url找到具体的处理器，返回处理器执行链HandlerExecutionChain，执行链包含生成的所有处理器对象handler及处理器拦截器(如果有则生成)，一并返回给DispatcherServlet。
4、 DispatcherServlet将处理器执行链HandlerExecutionChain交给HandlerAdapter处理器适配器，HandlerAdapter处理器适配器根据handler的类型（类型可以是注解，配置文件等）调用不同的处理器适配器（例如专门处理注解类型的适配器）。
5、 对应类型的处理器适配器会执行controller中url对应的handler，也就是方法执行了 。（handler是方法,Controller是指表现层处理的类）
6、 Controller执行完成返回ModelAndView
7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9、 ViewReslover根据ModelAndView中设置的视图的类型（类型可以是jsp,报表,pdf等），使用对应类型的视图解析器进行解析，解析后返回具体View
10、 DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中，将后台数据填充到前台页面）。
11、 DispatcherServlet响应用户

组件说明

以下组件通常使用框架提供实现：
DispatcherServlet：前端控制器
用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。
HandlerMapping：处理器映射器
HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式(实际开发中只用注解的方式)等。
DispatcherServlet.properties配置文件中HandlerMapping默认加载DefaultAnnotationHandlerMapping和BeanNameUrlHandlerMapping。
DefaultAnnotationHandlerMapping用来解析Spring MVC里面的annotation对应的Controller，也就是通过这个类，给Annotation设置映射关系，如@RequestMapping。
Handler：处理器
Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。而Controller是指表现层处理的类
由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。
 HandlAdapter：处理器适配器
通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。
补充：
DispatcherServlet.properties配置文件中HandlAdapter默认加载AnnotationMethodHandlerAdapter
AnnotationMethodHandlerAdapter对Annotation设置的方法进行处理的类，通过此类，解析annotation设置的类的处理（解析url和方法之间的映射关系），也就是有请求时，通过此类，可以调用annotation设置controller的方法,主要处理方法，handle(HttpServletRequest req, HttpServletResponse resp, Object handler)
 View Resolver：视图解析器
View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。
DispatcherServlet.properties配置文件中ViewResolver默认加载InternalResourceViewResolver
View：视图**
springmvc框架提供了很多的View视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是jsp。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。
说明：在springmvc的各个组件中，处理器映射器、处理器适配器、视图解析器称为springmvc的三大组件。
需要用户开发的组件有handler、view

手写自己的springmvc

设计思路

配置阶段

1.替换web.xml中配置的DispatcherServlet 为我们自己实现的DispatcherServlet
2.实现自己的@Controller @Service @Autowired@RequestMapping

初始化阶段

1.加载配置文件
加载配置的spirngmvc.xml或者application.properties
2.扫描配置的相关类
根据加载的配置文件内中配置的扫描包路径，查找对应包路径下的类
3.实例化扫描到的类，并放入到IOC容器中
将扫描到的类 实例化 并放入IOC容器中
4.依赖注入
对已经实例化的类中，有@Autowired注解的属性进行动态注入实例引用
5.整理requertMapping，把url和method对应起来放在一个k-v的Map中,在运行阶段取出
**

运行阶段

1.获取请求中的url ，从requestMapping中获取对应的方法
2.参数处理
3.执行方法
4.返回结果

demo

annotation：注解类

  1. import java.lang.annotation.*;
  3. /**
  4.  * 实现自己的Autowired
  5.  * @author Bai
  6.  * @date 2020/12/10 22:46
  7.  */
  8. @Target({ElementType.FIELD})
  9. @Retention(RetentionPolicy.RUNTIME)
  10. @Documented
  11. public @interface MyAutowired {
  12.     String value() default "";
  13. }
  1. import org.springframework.stereotype.Component;
  3. import java.lang.annotation.*;
  5. @Target({ElementType.TYPE})
  6. @Retention(RetentionPolicy.RUNTIME)
  7. @Documented
  8. @Component
  9. public @interface MyController {
  12.     String value() default "";
  14. }
  1. import java.lang.annotation.*;
  3. /**
  4.  * @author Bai
  5.  * @date 2020/12/10 20:59
  6.  */
  7. @Target({ElementType.METHOD, ElementType.TYPE})
  8. @Retention(RetentionPolicy.RUNTIME)
  9. @Documented
  10. @Mapping
  11. public @interface MyRequestMapping {
  13.         String value() default "";
  14. }
  2. import java.lang.annotation.*;
  4. /**
  5.  * @author Bai
  6.  * @date 2020/12/10 22:36
  7.  */
  8. @Target({ElementType.TYPE})
  9. @Retention(RetentionPolicy.RUNTIME)
  10. @Documented
  11. public @interface MyService {
  12.     String value() default "";
  13. }

通用controller or service

  1. /**
  2.  * @author Bai
  3.  * @date 2020/12/11 21:54
  4.  */
  5. @MyController
  6. @MyRequestMapping(value = "/login")
  7. public class LoginController {
  9.     @MyAutowired
  10.     private LoginService loginService;
  12.     @MyRequestMapping(value = "/userLogin")
  13.     public String login(HttpServletRequest request,
  14.                         @RequestParam(value = "name") String name,
  15.                         @RequestParam(value = "level", defaultValue = "123") Integer level) {
  16.         return request.getParameter("name") + loginService.login() + level;
  17.     }
  18. }
  1. /**
  2.  * @author Bai
  3.  * @date 2020/12/11 21:55
  4.  */
  5. @MyService
  6. public class LoginService {
  8.     public String login() {
  9.         return "登录成功";
  10.     }
  11. }

V1版本

  2. import com.alibaba.fastjson.JSONObject;
  3. import org.springframework.web.bind.annotation.RequestParam;
  4. import org.springframework.web.bind.annotation.ValueConstants;
  6. import javax.servlet.ServletConfig;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.http.HttpServlet;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import java.io.File;
  12. import java.io.IOException;
  13. import java.io.InputStream;
  14. import java.io.PrintWriter;
  15. import java.lang.reflect.Field;
  16. import java.lang.reflect.Method;
  17. import java.lang.reflect.Parameter;
  18. import java.net.URL;
  19. import java.util.*;
  21. /**
  22.  * 实现自己的springmvc 仿写 v1版本
  23.  *
  24.  * @author Bai
  25.  * @date 2020/12/10 21:03
  26.  */
  27. public class MyDispatcherServlet extends HttpServlet {
  29.     /**
  30.      * 上下文
  31.      */
  32.     private static Properties applicationContext = new Properties();
  34.     /**
  35.      * IOC容器 包路径：实例
  36.      */
  37.     private Map<String, Object> IOC = new HashMap<>();
  39.     /**
  40.      * 方法与url之间的映射
  41.      * key:url value:requestMapping
  42.      */
  43.     private Map<String, Method> methodRequestMapping = new HashMap<>();
  45.     /**
  46.      * 扫描到的类路径
  47.      */
  48.     private static List<String> classPathList = new ArrayList<>();
  50.     @Override
  51.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  52.         this.doPost(req, resp);
  53.     }
  55.     @Override
  56.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  57.         //解析requestMapping
  58.         String requestURI = req.getRequestURI();
  59.         if (!methodRequestMapping.containsKey(requestURI)) {
  60.             resp.getWriter().write("url not exit!");
  61.         }
  62.         //获取对应method
  63.         Method method = methodRequestMapping.get(requestURI);
  64.         if (null == method) {
  65.             return;
  66.         }
  67.         //获取方法所在类的实例
  68.         Object o = IOC.get(classNameToLower(method.getDeclaringClass().getSimpleName()));
  69.         try {
  70.             //封装入参
  71.             Object[] params = getParams(req, resp, method);
  72.             //执行方法
  73.             Object invokeResult = method.invoke(o, params);
  74.             if (null != invokeResult) {
  75.                 PrintWriter writer = resp.getWriter();
  76.                 resp.setCharacterEncoding("utf-8");
  77.                 resp.setContentType("text/html; charset=utf-8");
  78.                 writer.write(JSONObject.toJSONString(invokeResult));
  79.             }
  80.         } catch (Exception e) {
  81.             e.printStackTrace();
  82.             resp.getWriter().write("error 500" + e.getMessage());
  83.         }
  84.     }
  86.     private Object[] getParams(HttpServletRequest request, HttpServletResponse response, Method method) {
  87.         //获取方法上的参数列表
  88.         Parameter[] methodParameters = method.getParameters();
  89.         if (null == methodParameters || methodParameters.length < 1) {
  90.             return new Object[0];
  91.         }
  92.         //获取入参参数列表
  93.         Map<String, String[]> requestParameterMap = request.getParameterMap();
  94.         Object[] params = new Object[methodParameters.length];
  95.         for (int i = 0; i < methodParameters.length; i++) {
  96.             Parameter methodParameter = methodParameters[i];
  97.             if (methodParameter.getType() == HttpServletRequest.class) {
  98.                 params[i] = request;
  99.                 continue;
  100.             } else if (methodParameter.getType() == HttpServletResponse.class) {
  101.                 params[i] = response;
  102.                 continue;
  103.             }
  104.             //参数判断是否必选
  105.             RequestParam requestParam = methodParameter.getAnnotation(RequestParam.class);
  106.             String[] requestParameter = requestParameterMap.get(requestParam.value());
  107.             //如果没有给默认值，同时没有给入参 则报错
  108.             if (requestParam.required()
  109.                     && (null == requestParameter || requestParameter.length < 1)
  110.                     //RequestParam的默认值是ValueConstants.DEFAULT_NONE
  111.                     && ValueConstants.DEFAULT_NONE.equals(requestParam.defaultValue())) {
  112.                 throw new RuntimeException("error 500 " + requestParam.name() + " not null!");
  113.             }
  114.             //处理String类型 的参数
  115.             if (methodParameter.getType() == String.class) {
  116.                 String value = null;
  117.                 //先取默认值
  118.                 if (!ValueConstants.DEFAULT_NONE.equals(requestParam.defaultValue())) {
  119.                     value = requestParam.defaultValue();
  120.                 }
  121.                 if (null != requestParameter && requestParameter.length > 0) {
  122.                     StringBuilder sb = new StringBuilder();
  123.                     for (String s : requestParameter) {
  124.                         sb.append(s);
  125.                     }
  126.                     value = sb.toString();
  127.                 }
  128.                 params[i] = value;
  129.             }
  130.             //处理Inter类型 的参数
  131.             if (methodParameter.getType() == Integer.class) {
  132.                 Integer value = null;
  133.                 //先取默认值
  134.                 if (!ValueConstants.DEFAULT_NONE.equals(requestParam.defaultValue())) {
  135.                     value = Integer.valueOf(requestParam.defaultValue());
  136.                 }
  137.                 if (null != requestParameter && requestParameter.length > 0) {
  138.                     StringBuilder sb = new StringBuilder();
  139.                     for (String s : requestParameter) {
  140.                         sb.append(s);
  141.                     }
  142.                     value = Integer.valueOf(sb.toString());
  143.                 }
  144.                 params[i] = value;
  145.             }
  146.         }
  147.         return params;
  148.     }
  150.     @Override
  151.     public void init(ServletConfig config) throws ServletException {
  152.         //1.加载配置文件
  153.         doLoadContextConfig(config.getInitParameter("contextConfigLocation"));
  154.         //2.扫描相关类
  155.         doComponentScan(String.valueOf(applicationContext.get("componentScan")));
  156.         //3.实例化并且放入ioc容器内
  157.         doInstance();
  158.         //4.依赖注入
  159.         doAutowired();
  160.         //5.初始化handlerMapping
  161.         initHandlerMapping();
  162.     }
  164.     /**
  165.      * 存储 url 与方法之间的映射
  166.      */
  167.     private void initHandlerMapping() {
  168.         if (IOC.isEmpty()) {
  169.             return;
  170.         }
  171.         for (Object object : IOC.values()) {
  172.             //非MyController注释类不处理
  173.             final Class<?> aClass = object.getClass();
  174.             if (!aClass.isAnnotationPresent(MyController.class)) {
  175.                 continue;
  176.             }
  177.             //获取类 requestMapping
  178.             String name = aClass.getAnnotation(MyRequestMapping.class).value();
  179.             //获取所有被MyRequestMapping注解的方法
  180.             Method[] methods = aClass.getMethods();
  181.             for (Method method : methods) {
  182.                 if (!method.isAnnotationPresent(MyRequestMapping.class)) {
  183.                     continue;
  184.                 }
  185.                 //获取方法 requestMapping
  186.                 String requestMapping = name + method.getAnnotation(MyRequestMapping.class).value();
  187.                 if (methodRequestMapping.containsKey(requestMapping)) {
  188.                     throw new RuntimeException(requestMapping + " is exist");
  189.                 }
  190.                 methodRequestMapping.put(requestMapping, method);
  191.             }
  192.         }
  193.     }
  195.     /**
  196.      * 依赖注入
  197.      */
  198.     private void doAutowired() {
  199.         if (IOC.isEmpty()) {
  200.             return;
  201.         }
  202.         for (Object object : IOC.values()) {
  203.             Class<?> aClass = object.getClass();
  204.             //MyAutowired一般是放在成员属性上
  205.             //获取所有成员属性
  206.             Field[] declaredFields = aClass.getDeclaredFields();
  207.             for (Field declaredField : declaredFields) {
  208.                 // 判断是否有MyAutowired注解
  209.                 if (declaredField.isAnnotationPresent(MyAutowired.class)) {
  210.                     String name = declaredField.getName();
  211.                     if (IOC.containsKey(name)) {
  212.                         try {
  213.                             declaredField.setAccessible(true);
  214.                             declaredField.set(object, IOC.get(name));
  215.                         } catch (IllegalAccessException e) {
  216.                             e.printStackTrace();
  217.                             throw new RuntimeException(name + " not in IOC!");
  218.                         }
  219.                     }
  220.                 }
  221.             }
  222.         }
  223.     }
  225.     /**
  226.      * 实例化对象并且放入IOC容器中
  227.      */
  228.     private void doInstance() {
  229.         if (classPathList.isEmpty()) {
  230.             return;
  231.         }
  232.         for (String clazzPath : classPathList) {
  233.             //通过反射获取class对象
  234.             Class aClass = getClass(clazzPath);
  235.             //非MyController MyService注解不实例化
  236.             if (!aClass.isAnnotationPresent(MyController.class)
  237.                     && !aClass.isAnnotationPresent(MyService.class)) {
  238.                 continue;
  239.             }
  240.             if (IOC.containsKey(aClass.getName())) {
  241.                 throw new RuntimeException(aClass.getName() + " is exits in IOC!");
  242.             }
  243.             try {
  244.                 IOC.put(classNameToLower(aClass.getSimpleName()), aClass.newInstance());
  245.             } catch (Exception e) {
  246.                 System.out.println(e.getMessage());
  247.             }
  248.         }
  249.     }
  251.     private String classNameToLower(String simpleName) {
  252.         char[] chars = simpleName.toCharArray();
  253.         chars[0] += 32;
  254.         return new String(chars);
  255.     }
  257.     private Class getClass(String clazzPath) {
  258.         try {
  259.             return Class.forName(clazzPath);
  260.         } catch (ClassNotFoundException e) {
  261.             e.printStackTrace();
  262.         }
  263.         return null;
  264.     }
  266.     /**
  267.      * 根据配置包路径扫描类
  268.      *
  269.      * @param componentScan 配置的扫描路径
  270.      */
  271.     private void doComponentScan(String componentScan) {
  272.         //将路径转换为相对路径
  273.         String path = componentScan.replaceAll("\\.", "/");
  274.         //加载系统文件路径
  275.         URL url = this.getClass().getClassLoader().getResource(path);
  276.         System.out.println(url.getFile());
  278.         File classPath = new File(url.getFile());
  280.         for (File file : classPath.listFiles()) {
  281.             //如果是文件夹 则继续递归
  282.             if (file.isDirectory()) {
  283.                 doComponentScan(componentScan + "." + file.getName());
  284.             } else {
  285.                 //只加载class文件
  286.                 if (!file.getName().endsWith(".class")) {
  287.                     continue;
  288.                 }
  289.                 String className = (componentScan + "." + file.getName()).replace(".class", "");
  290.                 classPathList.add(className);
  291.             }
  292.         }
  293.     }
  295.     /**
  296.      * 加载applicationContext
  297.      *
  298.      * @param initParameter
  299.      */
  300.     private void doLoadContextConfig(String initParameter) {
  301.         InputStream inputStream = null;
  302.         try {
  303.             inputStream = this.getClass().getClassLoader().getResourceAsStream(initParameter);
  304.             applicationContext.load(inputStream);
  305.         } catch (IOException e) {
  306.             System.out.println(e.getMessage());
  307.         } finally {
  308.             if (null != inputStream) {
  309.                 try {
  310.                     inputStream.close();
  311.                 } catch (IOException e) {
  312.                     e.printStackTrace();
  313.                 }
  314.             }
  315.         }
  316.     }
  317. }

**