1.SpringMVC的工作流程

SpringMVC - 图1

  • 客户发送请求 （request）
  • 请求交由核心处理（DispatcherServlet）
  • 核心控制器找到映射器，映射器看看请求路径是什么（HandleMapping）
  • 控制器再找到适配器，看看有哪些类实现了Controller接口或者对应的Bean对象（HandleAdapter）
  • 将带过来的数据进行转换，格式化等等操作 找到我们的控制器Action，处理完业务之后返回
  • 最后通过视图解析器来对ModelAndView进行解析
  • 跳转到对应的JSP/html页面

    2.核心代码

    2.1 在web.xml中配置使得controller的请求都经过DispatcherServlet

    image.png

    2.2DispatcherServlet

    ```java package com.woniuxy.myspringmvc.core;

import java.io.File; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.List; 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.fasterxml.jackson.databind.ObjectMapper; import com.woniuxy.myspringmvc.annotation.ResponseBody; import com.woniuxy.myspringmvc.annotation.ResponseForward; import com.woniuxy.myspringmvc.annotation.ResponseRedirect;

public class DispatcherServlet extends HttpServlet { private static final long serialVersionUID = 1L; // 配置文件 private Properties configProp = new Properties(); // 获取包下controller类全名 private List classNames = new ArrayList(); private HandlerMapper handlerMapper; private HandlerAdapter handlerAdapter; public void init(ServletConfig config) throws ServletException { // 初始化 System.out.println(“初始化”); // 加载配置文件，读取内容 loadProperties(config); // 扫描指定包下的类，获取该包下的所有类全名，并去存储到classNames中 doScanner(configProp.getProperty(“package”)); //创建处理器映射对象 handlerMapper=new HandlerMapper(classNames); //创建处理器适配器对象 handlerAdapter=new HandlerAdapter(handlerMapper); }

  1. private void doScanner(String packageName) {
  2.     // 类全名：包名+类名
  3.     // 将包名转化为文件路径
  4.     String packagePath = packageName.replaceAll("\\.", "/");
  5.     // 获取src文件下的真实路径，widow中空格是%20，要将他转换成空格
  6.     String path = DispatcherServlet.class.getClassLoader().getResource(packagePath).getPath().replace("%20", " ");
  7.     // 创建file对象
  8.     File file = new File(path);
  9.     // 判断文件是否存在
  10.     if (!file.exists()) {
  11.         return;
  12.     }
  13.     // 获取子文件
  14.     File[] files = file.listFiles();
  15.     for (File f : files) {
  16.         if (f.isDirectory()) {
  17.             doScanner(packageName + "." + f.getName());
  18.         } else {
  19.             // 获取源文件名称
  20.             String fileName = f.getName();
  21.             // 获取类名
  22.             String name = fileName.replace(".class", "");
  23.             // 类全名
  24.             String className = packageName + "." + name;
  25.             // 存储到controllers中
  26.             //System.out.println(className);
  27.             classNames.add(className);
  28.         }
  29.     }
  30.     System.out.println(path);
  31. }
  33. private void loadProperties(ServletConfig config) {
  34.     // 根据name获取servlet初始化参数值
  35.     String configName = config.getInitParameter("config");
  36.     // 如果用户配置了文件名，则以配置的为准，否则取默认值
  37.     if (configName == null) {
  38.         configName = "application.properties";
  39.     }
  40.     InputStream is = null;
  41.     try {
  42.         is = DispatcherServlet.class.getClassLoader().getResourceAsStream(configName);
  43.         configProp.load(is);
  44.     } catch (Exception e) {
  45.         e.printStackTrace();
  46.     } finally {
  47.         try {
  48.             if (is != null)
  49.                 is.close();
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  55. }
  57. protected void service(HttpServletRequest request, HttpServletResponse response)
  58.         throws ServletException, IOException {
  59.     Object result = handlerAdapter.adapter(request, response);
  60.     if (result==null) {
  61.         return;
  62.     }
  63.     //获取当前方法对象
  64.     Method method=handlerMapper.getMethodMapper().get(request.getPathInfo());
  65.     if (method.isAnnotationPresent(ResponseBody.class)) {
  66.         //设置响应内容类型
  67.         response.setContentType("application/json;charset=utf-8");
  68.         //将返回值的java对象转化成json,并通过指定输出流写出
  69.         new ObjectMapper().writeValue(response.getOutputStream(),result);
  70.     }else if(method.isAnnotationPresent(ResponseForward.class)){
  71.         String path=(String)result;
  72.         //请求转发
  73.         request.getRequestDispatcher("../../"+path).forward(request, response);
  74.     }else if(method.isAnnotationPresent(ResponseRedirect.class)){
  75.         String path=(String)result;
  76.         //重定向
  77.         response.sendRedirect(path);
  78.     }
  79. }

}

  1. <a name="6zImK"></a>
  2. ## 2.3HandlerMapping
  3. ```java
  4. package com.woniuxy.myspringmvc.core;
  6. import java.lang.reflect.Method;
  7. import java.util.HashMap;
  8. import java.util.List;
  9. import java.util.Map;
  11. import com.woniuxy.myspringmvc.annotation.Controller;
  12. import com.woniuxy.myspringmvc.annotation.RequestMapping;
  14. public class HandlerMapper {
  15.     // 存储controller的实例,键：类名，值：对应controller对象
  16.     private Map<String, Object> controllers = new HashMap<String, Object>();
  17.     // 存储请求URL与controller映射，键：请求URL，值controller对象
  18.     private Map<String, Object> controllerMapper = new HashMap<String, Object>();
  19.     // 存储请求URL与controller映射，键：请求URL，值controller对象的方法
  20.     private Map<String, Method> methodMapper = new HashMap<String, Method>();
  22.     public HandlerMapper(List<String> classNames) {
  23.         // 实例化：创建添加了controller注解的controller对象，并存储到controllers中
  24.         doInstance(classNames);
  25.         // 建立映射，建立请求与controller的方法映射
  26.         initHandlerMapper();
  27.     }
  29.     private void initHandlerMapper() {
  30.         // 循环遍历每个controller对象
  31.         for (Object controller : controllers.values()) {
  32.             // 获取当前controller对象的class实例;
  33.             Class cl = controller.getClass();
  34.             // 判断当前controller类上是否存在RequestMapping注解
  35.             if (cl.isAnnotationPresent(RequestMapping.class)) {
  36.                 // 获取requestmapping注解
  37.                 RequestMapping controllerRequestMapping = (RequestMapping) cl
  38.                         .getDeclaredAnnotation(RequestMapping.class);
  39.                 // 获取注解值
  40.                 String controllerRequestMappingValue = controllerRequestMapping.value();
  41.                 // 获取controller类所有方法
  42.                 Method[] methods = cl.getDeclaredMethods();
  43.                 for (Method method : methods) {
  44.                     // 判断当前方法是否存在requestmapping注解
  45.                     if (method.isAnnotationPresent(RequestMapping.class)) {
  46.                         // 获取当前方法的requestmapping注解
  47.                         RequestMapping methodRequestMapping = method.getDeclaredAnnotation(RequestMapping.class);
  48.                         // 获取当前方法上的request1mapping注解值
  49.                         String methodRequestMappingValue = methodRequestMapping.value();
  50.                         // 生成键
  51.                         String key = controllerRequestMappingValue + methodRequestMappingValue;
  52.                         // 建立请求与controller的映射
  53.                         controllerMapper.put(key, controller);
  54.                         // 建立请求与method的映射
  55.                         methodMapper.put(key, method);
  56.                     }
  57.                 }
  58.             }
  59.         }
  60.     }
  62.     private void doInstance(List<String> classNames) {
  63.         // 循环遍历每个controller全类名
  64.         for (String className : classNames) {
  65.             try {
  66.                 // 通过类全名获取class实例
  67.                 Class cl = Class.forName(className);
  68.                 // 判断当前controller上是否存在controlle注解
  69.                 if (cl.isAnnotationPresent(Controller.class)) {
  70.                     // 创建目标controller对象
  71.                     Object o = cl.newInstance();
  72.                     // 存储到controllers中
  73.                     controllers.put(cl.getSimpleName(), o);
  74.                 }
  75.             } catch (Exception e) {
  76.                 e.printStackTrace();
  77.             }
  79.         }
  81.     }
  83.     public Map<String, Object> getControllers() {
  84.         return controllers;
  85.     }
  87.     public void setControllers(Map<String, Object> controllers) {
  88.         this.controllers = controllers;
  89.     }
  91.     public Map<String, Object> getControllerMapper() {
  92.         return controllerMapper;
  93.     }
  95.     public void setControllerMapper(Map<String, Object> controllerMapper) {
  96.         this.controllerMapper = controllerMapper;
  97.     }
  99.     public Map<String, Method> getMethodMapper() {
  100.         return methodMapper;
  101.     }
  103.     public void setMethodMapper(Map<String, Method> methodMapper) {
  104.         this.methodMapper = methodMapper;
  105.     }
  107. }

2.4HandlerAdapter

  1. package com.woniuxy.myspringmvc.core;
  3. import java.io.IOException;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.Parameter;
  7. import java.util.Iterator;
  8. import java.util.Map;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  12. public class HandlerAdapter {
  13.     private HandlerMapper handlerMapper;
  15.     public HandlerAdapter(HandlerMapper handlerMapper) {
  16.         this.handlerMapper = handlerMapper;
  17.     }
  19.     public Object adapter(HttpServletRequest request, HttpServletResponse response) throws IOException {
  20.         Object result = null;
  21.         // 获取请求的映射键
  22.         String key = request.getPathInfo();
  23.         // 根据键查找对应controller对象以及method对象
  24.         Object controller = handlerMapper.getControllerMapper().get(key);
  25.         Method method = handlerMapper.getMethodMapper().get(key);
  26.         if (controller == null | method == null) {
  27.             response.sendError(404, "请求的controller或method不存在！");
  28.             return result;
  29.         }
  30.         // 获取参数个数
  31.         int methodParamCount = method.getParameterCount();
  32.         // 存储方法参数实参
  33.         Object[] realMethodParams = new Object[methodParamCount];
  34.         // 获取页面所有参数的map对象
  35.         Map<String, String[]> pageParamVals = request.getParameterMap();
  36.         // 获取方法所有参数
  37.         Parameter[] methodParames = method.getParameters();
  38.         for (int i = 0; i < methodParames.length; i++) {
  39.             // 每一个形参
  40.             Parameter methodParam = methodParames[i];
  41.             // 获取方法参数类型
  42.             Class methodParamTypeCl = methodParam.getType();
  43.             // 获取参数方法名称
  44.             String methodTypeName = methodParamTypeCl.getSimpleName();
  45.             // 获取方法参数名称
  46.             String methodParamName = methodParam.getName();
  47.             // 判断参数数据类型
  48.             if (methodTypeName.equals("HttpServletRequest")) {
  49.                 realMethodParams[i] = request;
  50.             } else if (methodTypeName.equals("HttpServletResponse")) {
  51.                 realMethodParams[i] = response;
  52.             } else if (methodParamTypeCl.getClassLoader() == null) {
  53.                 // java自带类型，比如String、int等
  54.                 // 取出当前方法的参数的实参
  55.                 String[] pageParamVal = pageParamVals.get(methodParamName);
  56.                 // 判断参数是否存在
  57.                 if (pageParamVal == null) {
  58.                     response.sendError(404, method.getName() + "方法的" + methodParamName + "参数不存在！");
  59.                     return result;
  60.                 }
  61.                 // 将客户端传参进行类型转换
  62.                 realMethodParams[i] = parseType(pageParamVal, methodParamTypeCl);
  63.             } else {
  64.                 // 自定义类型
  65.                 Object o = null;
  66.                 try {
  67.                     // 创建目标类对象
  68.                     o = methodParamTypeCl.newInstance();
  69.                     // 获取当前类的属性
  70.                     Field[] files = methodParamTypeCl.getDeclaredFields();
  71.                     for (Field field : files) {
  72.                         // 获取当前属性名称
  73.                         String fieldName = field.getName();
  74.                         // 根据属性名和方法参数名称获取前端参数键
  75.                         String pageParamKey = methodParamName + "." + fieldName;
  76.                         // 尝试从前端参数中取值
  77.                         String[] pageParamVal = pageParamVals.get(pageParamKey);
  78.                         if (pageParamVal == null) {
  79.                             continue;
  80.                         }
  81.                         // 获取当前属性类型
  82.                         Class fieldTypeCl = field.getType();
  83.                         // 将String转为真实类型
  84.                         Object val = parseType(pageParamVal, fieldTypeCl);
  85.                         // 赋值
  86.                         // 获取set方法名称
  87.                         String fieldSetMethodName = "set" + (fieldName.charAt(0) + "").toUpperCase()
  88.                                 + fieldName.substring(1);
  89.                         // 获取set方法对象
  90.                         Method fieldSetMethod = methodParamTypeCl.getDeclaredMethod(fieldSetMethodName, fieldTypeCl);
  91.                         // 执行set方法，赋值
  92.                         fieldSetMethod.invoke(o, val);
  93.                     }
  94.                 } catch (Exception e) {
  95.                     e.printStackTrace();
  96.                 }
  97.                 realMethodParams[i] = o;
  98.             }
  99.         }
  100.         try {
  101.             result = method.invoke(controller, realMethodParams);
  102.         } catch (Exception e) {
  103.             e.printStackTrace();
  104.         }
  105.         return result;
  106.     }
  108.     private Object parseType(String[] pageParamVal, Class methodTypeCl) {
  109.         Object val = null;
  110.         // 存储当前目标类型是否为数组类型
  111.         boolean isArray = false;
  112.         // 存储元素类型名称
  113.         String aimTypeName = null;
  114.         // 判断目标类型是否为数组
  115.         if (methodTypeCl.isArray()) {
  116.             isArray = true;
  117.             aimTypeName = methodTypeCl.getComponentType().getSimpleName();
  118.         } else {
  119.             aimTypeName = methodTypeCl.getSimpleName();
  120.         }
  121.         // 分别判断目标类型，进行类型转换
  122.         if (aimTypeName.equals("String")) {
  123.             // 为数组
  124.             if (isArray) {
  125.                 val = pageParamVal;
  126.             } else {
  127.                 val = pageParamVal[0];
  128.             }
  129.         } else if (aimTypeName.equals("int")) {
  130.             if (isArray) {
  131.                 int[] array = new int[pageParamVal.length];
  132.                 for (int i = 0; i < pageParamVal.length; i++) {
  133.                     array[i] = Integer.parseInt(pageParamVal[i]);
  134.                 }
  135.                 val = array;
  136.             } else {
  137.                 int v = Integer.parseInt(pageParamVal[0]);
  138.                 val = v;
  139.             }
  140.         } else if (aimTypeName.equals("byte")) {
  141.             if (isArray) {
  142.                 byte[] array = new byte[pageParamVal.length];
  143.                 for (int i = 0; i < pageParamVal.length; i++) {
  144.                     array[i] = Byte.parseByte(pageParamVal[i]);
  145.                 }
  146.                 val = array;
  147.             } else {
  148.                 byte v = Byte.parseByte(pageParamVal[0]);
  149.                 val = v;
  150.             }
  151.         } else if (aimTypeName.equals("boolean")) {
  152.             if (isArray) {
  153.                 Boolean[] array = new Boolean[pageParamVal.length];
  154.                 for (int i = 0; i < pageParamVal.length; i++) {
  155.                     array[i] = Boolean.parseBoolean(pageParamVal[i]);
  156.                 }
  157.                 val = array;
  158.             } else {
  159.                 Boolean v = Boolean.parseBoolean(pageParamVal[0]);
  160.                 val = v;
  161.             }
  162.         }else if (aimTypeName.equals("double")) {
  163.             if (isArray) {
  164.                 Double[] array = new Double[pageParamVal.length];
  165.                 for (int i = 0; i < pageParamVal.length; i++) {
  166.                     array[i] = Double.parseDouble(pageParamVal[i]);
  167.                 }
  168.                 val = array;
  169.             } else {
  170.                 Double v = Double.parseDouble(pageParamVal[0]);
  171.                 val = v;
  172.             }
  173.         }else if (aimTypeName.equals("char")) {
  174.             if (isArray) {
  175.                 Character[] array = new Character[pageParamVal.length];
  176.                 for (int i = 0; i < pageParamVal.length; i++) {
  177.                     array[i] = pageParamVal[i].charAt(0);
  178.                 }
  179.                 val = array;
  180.             } else {
  181.                 Character v = pageParamVal[0].charAt(0);
  182.                 val = v;
  183.             }
  184.         }
  185.         return val;
  186.     }
  187. }

2.5注解

annotation.zip