手写SpringMVC底层机制-Toy模板网

这篇具有很好参考价值的文章主要介绍了手写SpringMVC底层机制。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

手写 SpringMVC 底层机制

前景提要：实现的是SpringMVC核心机制
对一些细枝末节的代码做了简化，比如字符串的处理...
完成哪些机制
- 机制一：通过@RequestMapping ，可以标记一个方法，编写路径url，浏览器就能通过url完成调用
- 机制二：进行依赖注入，使之不需要传统的new 一个对象，而是直接从IOC容器中获得
- 机制三：通过@RequestParam，如果浏览器传递的参数名和目标方法的形参不一致，可以通过value设置进行匹配
- 机制四：在目标方法完成后，跳转到相关页面请求转发/重定向
- 机制五：在目标方法完成后，通过@Response注解，向浏览器发送JSON格式数据

手写添加配置

思路

需要配置pom.xml的依赖
需要写一个Servlet 作为前端控制器
需要配置Web.xml 中的前端控制器 1).url 2）配置spring容器配置文件的classpath： 3)跟随Tomcat 自启动
需要配置spring容器配置文件
需要配置spring容器配置文件扫描的路径 <component-scan ...>

实现

需要配置pom.xml的依赖

<!--  配置原生Servlet-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    <!--  <scope> 表示引入的jar的作用范围
          provided 表示该项目在打包 放到生产环境时，不需要带上 servlet-api.jar
          因为tomcat本身有 servlet-api.jar，到时直接使用tomcat本身的 servlet-api.jar-->
    </dependency>

  <!--  配置dom4j-->
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.1</version>
    </dependency>

  <!--  配置常用的工具类-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.12.0</version>
    </dependency>

需要写一个Servlet 作为前端控制器

public class ZyDispatcherServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("ZyDispatcherServlet-doPost--");
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("ZyDispatcherServlet-doGet--");
    }
}

需要配置Web.xml 中的前端控制器 1).url 2）配置spring容器配置文件的classpath： 3)跟随Tomcat 自启动
需要配置spring容器配置文件扫描的路径 <component-scan ...>

 <servlet>
    <servlet-name>ZyDispatcherServlet</servlet-name>
    <servlet-class>com.code_study.zyspringmvc.servlet.ZyDispatcherServlet</servlet-class>
    
    <!--配置参数，指定要操作的spring配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:zyspringmvc.xml</param-value>
    </init-param>

    <!--跟随tomcat自启动-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>ZyDispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

需要配置spring容器配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <!--    要扫描的包-->
    <component-scan base-package="com.code_study.controller,com.code_study.service"></component-scan>
</beans>

完成浏览器可以请求控制层

思路

创建@Controller和自己的Controller
编写工具类XMLParser，解析spring容器配置文件
开发自己的 Spring容器，得到扫描类的全路径列表
开发自己的前端控制器，实例化对象到容器中
完成请求的URL和控制器方法的映射关系
完成前端控制器分发请求到对应控制器

自定义注解@Controller
创建Controller
需要写一个工具类XMLParser来解析在spring容器配置文件扫描的路径 <component-scan ...> 的包返回所有的路径
这个所有的路径一个split（",")分隔，都进行扫描
需要写自己的前端控制器
需要写自己的 Spring容器
在前端控制器中需要添加方法 scanPackage（）扫描 XMLParser 解析出来的路径
在Spring容器中需要添加一个属性 classFullPathList 来保存扫描出来的类的全路径
需要添加一个属性 ioc 来存放反射生成的bean对象也就是过滤classFullPathList 中没有@Controller注解的一些路径并实例化
需要添加类Handler 这个类要保存一个url 对应的一个控制器的方法的映射，也就是说，根据这个url，可以找到对应控制器的对应方法
需要添加一个属性 HandlerList 用于保存Handler 【url 和控制器的映射】
需要添加三个方法一个是initHandlerMapping（），完成 url 对应的一个控制器的方法的映射，即将ioc 中bean 中的方法进行反射，获取url，将 url，method，bean 封装成Handler 放入HandlerList 保存
添加第二个方法 getHandler（），需要将浏览器发送的request请求中的 uri拿出来，遍历HandlerList 进行配对，如果有就返回对应的Handler
添加第三个方法 executeDispatch（），进行分发处理，需要调用getHandler（）获取浏览器发送的request请求对应的 Handler ，获取Handler 中的method 进行反射调用，method .invoke() 实现分发请求。

实现

自定义注解@Controller

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {
    String value() default "";
}

创建Controller

@Controller
public class MonsterController {
}

需要写一个工具类XMLParser来解析在spring容器配置文件扫描的路径 <component-scan ...> 的包返回所有的路径

public class XMLParser {

    public static String getBasePackage(String xmlFile){
        SAXReader saxReader = new SAXReader();
        ClassLoader classLoader = XMLParser.class.getClassLoader();
        InputStream resourceAsStream = classLoader.getResourceAsStream(xmlFile);
        try {
            Document document = saxReader.read(resourceAsStream);
            Element rootElement = document.getRootElement();
            Element element = rootElement.element("component-scan");
            String basePackage = element.attribute("base-package").getText();
            return basePackage;
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }
}

这个所有的路径一个split（",")分隔，都进行扫描
需要写自己的前端控制器
需要写自己的 Spring容器
在前端控制器中需要添加方法 scanPackage（）扫描 XMLParser 解析出来的路径

public void scanPackage(String pack) {
        //获得包所在的工作路径 [绝对路径]
        URL url =
                this.getClass().getClassLoader().//获取类的加载器
                        //得到指定包对应的工作路径 [绝对路径]
                                getResource("/" + pack.replaceAll("\\.", "/"));

        // System.out.println("url= "+url);
        //根据得到的路径，对其进行扫描，把类的全路径 保存到 classFullPathList
        String path = url.getFile();
        //在io中 把目录也是为一个文件
        File file = new File(path);
        //遍历file 【遍历出文件和子目录】
        for (File f : file.listFiles()) {
            if (f.isDirectory()) {//如果是目录
                //需要递归扫描 找子目录
                scanPackage(pack + "." + f.getName());
            } else {
                //的确是个文件
                //扫描到的文件可能是 .class 文件 也可能是其他文件
                //就算是.class 文件 也需要判断是否需要注入容器 有无加 @Controller注解
                //目前无法拿到注解 因为没法反射 所以先把文件的全路径都保存到 classFullPathList 之后在注入对象到容器时再处理
                String classFullPath =
                        //类的全路径不需要.class 去掉.class
                        pack + "." + f.getName().replaceAll(".class", "");

                //保存到 classFullPathList
                classFullPathList.add(classFullPath);
            }
        }
    }

在Spring容器中需要添加一个属性 classFullPathList 来保存扫描出来的类的全路径

//保存扫描的包/子包类的全路径
    private List<String> classFullPathList =
            new ArrayList<>();

需要添加一个属性 ioc 来存放反射生成的bean对象也就是过滤classFullPathList 中没有@Controller注解的一些路径并实例化

//定义属性 ioc -> 存放反射生成的bean对象 比如Controller / Service /Dao
public ConcurrentHashMap<String, Object> ioc =
        new ConcurrentHashMap<>();

编写方法，将扫描到的类，在满足情况下反射到ioc容器

//编写方法，将扫描到的类，在满足情况下 反射到ioc容器
    public void executeInstance() {
        if (classFullPathList.size() == 0) {
            //说明没有扫描到类
            return;
        }

        //遍历classFullList
        for (String classFullPath : classFullPathList) {
            try {
                Class<?> clazz = Class.forName(classFullPath);
                if (clazz.isAnnotationPresent(Controller.class)) {//处理@Controller
                    String className = clazz.getSimpleName();

                    Object instance = clazz.newInstance();
                    String value = clazz.getAnnotation(Controller.class).value();
                    if (!"".equals(value)) {
                        className = value;
                    } else {
                        className = StringUtils.uncapitalize(className);
                    }
                    ioc.put(className, instance);
                }
                else if (clazz.isAnnotationPresent(Service.class)) {//处理@Service
                    String className = clazz.getSimpleName();//类名

                    Service serviceAnnotation = clazz.getAnnotation(Service.class);
                    String value = serviceAnnotation.value();

                    if (!"".equals(value)) {
                        className = value;
                        Object instance = clazz.newInstance();
                        ioc.put(className, instance);
				}
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

需要添加类Handler 这个类要保存一个url 对应的一个控制器的方法的映射，也就是说，根据这个url，可以找到对应控制器的对应方法

ZyHandler {
    private String url;
    private Method method;
    private Object controller;

    public ZyHandler() {
    }

    public ZyHandler(String url, Method method, Object controller) {
        this.url = url;
        this.method = method;
        this.controller = controller;
    }
//需要提供getter和setter方法...

需要添加一个属性 HandlerList 用于保存Handler 【url 和控制器的映射】

//定义属性 HandlerList -> 保存ZyHandler 【url 和 控制器的映射】
    private List<ZyHandler> HandlerList =
            new ArrayList<>();

需要添加三个方法一个是initHandlerMapping（），完成 url 对应的一个控制器的方法的映射，即将ioc 中bean 中的方法进行反射，获取url，将 url，method，bean 封装成Handler 放入HandlerList 保存

 private void initHandlerMapping(){
        //遍历 ioc
        for (Map.Entry<String,Object> entry:  zyWebApplicationContext.ioc.entrySet()) {
            if (zyWebApplicationContext.ioc.isEmpty()){
                return;
            }
            Object bean = entry.getValue();
            Class<?> clazz = bean.getClass();
            if (clazz.isAnnotationPresent(Controller.class)){
                Method[] declaredMethods = clazz.getDeclaredMethods();
                for (Method declaredMethod : declaredMethods) {
                    if (declaredMethod.isAnnotationPresent(RequestMapping.class)){

                        String url = declaredMethod.getAnnotation(RequestMapping.class).value();

                        ZyHandler zyHandler = new ZyHandler(url, declaredMethod, bean);

                        HandlerList.add(zyHandler);
                    }
                }
            }
        }
    }

添加第二个方法 getHandler（），需要将浏览器发送的request请求中的 uri拿出来，遍历HandlerList 进行配对，如果有就返回对应的Handler

 //编写方法，通过request对象 返回ZyHandler对象 ，如果没有返回null
    private ZyHandler getZyHandler(HttpServletRequest request) {
        String requestURI = request.getRequestURI();
        //遍历HandlerList
        for (ZyHandler zyHandler : HandlerList) {
            if (requestURI.equals(zyHandler.getUrl())){
                return zyHandler;
            }
        }
        return null;
    }

添加第三个方法 executeDispatch（），进行分发处理，需要调用getHandler（）获取浏览器发送的request请求对应的 Handler ，获取Handler 中的method 进行反射调用，method .invoke() 实现分发请求。

   public void executeDispatch(HttpServletRequest request,HttpServletResponse response){
        ZyHandler zyHandler = getZyHandler(request);
        try {
            if (null == zyHandler){
               response.getWriter().write("<h1>404 NOT FOUND</h1>");
            }
            Method method = zyHandler.getMethod();
            method.invoke(zyHandler.getController(),request,response);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

从web.xml文件中动态获取spring配置文件

思路

首先，我们自己写的前端控制器是一个Servlet，它有 servletConfig，可以servletConfig.getInitParameter("xxx") 来获取之前在web.xml配置的classpath：
工具类XMLParser 是在spring容器中解析的，web.xml配置的classpath：是在前端控制器中获取的，因此需要spring容器提供有参构造器，在前端控制器添加参数 spring容器，将classpath 传到spring容器中进行解析。

实现

首先，我们自己写的前端控制器是一个Servlet，它有 servletConfig，可以servletConfig.getInitParameter("xxx") 来获取之前在web.xml配置的classpath：
工具类XMLParser 是在spring容器中解析的，web.xml配置的classpath：是在前端控制器中获取的，因此需要spring容器提供有参构造器，在前端控制器添加参数 spring容器，将classpath 传到spring容器中进行解析。

@Override
    public void init() throws ServletException {
        String configLocation = getServletConfig().getInitParameter("contextConfigLocation");
        System.out.println("ZyDispatcherServlet 初始化---");
        zyWebApplicationContext = new ZyWebApplicationContext(configLocation);
        zyWebApplicationContext.init();

        initHandlerMapping();
        System.out.println("HandlerList= "+HandlerList);

    }

 private  String configLocation;
    public ZyWebApplicationContext(String configLocation) {
        this.configLocation = configLocation;
    }

 public void init(){
        System.out.println("ZyWebApplicationContext 初始化---");
        String basePackage = XMLParser.getBasePackage(configLocation.split(":")[1]);
        String[] basePackages = basePackage.split(",");
        if (basePackages.length >0) {
            for (String  pack : basePackages) {
                scanPackage(pack);
            }
        }
 }

@Service注解

思路

@Service注解是写在类上的即@Target(ElementType.TYPE)
这个注解标识的类就是一个Service，那么同样是在executeInstance()方法中判断是否有注解@Service，有的话就保存到ioc容器中
由于是Service，那么保存进ioc 的 k-v 中的 k 就有三种。第一种，就是默认值，用接口的类型的名字首字母小写；第二种，在@Service注解种设置了value属性，那么 k = value；第三章，需要用类名首字母小写也可以获取bean

实现

@Service注解是写在类上的即@Target(ElementType.TYPE)

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {
    String value() default "";
}

这个注解标识的类就是一个Service，那么同样是在executeInstance()方法中判断是否有注解@Service，有的话就保存到ioc容器中
由于是Service，那么保存进ioc 的 k-v 中的 k 就有三种。第一种，就是默认值，用接口的类型的名字首字母小写；第二种，在@Service注解种设置了value属性，那么 k = value；第三章，需要用类名首字母小写也可以获取bean

 public void executeInstance() {
        if (classFullPathList.size() == 0){
            return;
        }
        //遍历 classFullPathList
        for (String classFullPath : classFullPathList) {
            try {
                Class<?> clazz = Class.forName(classFullPath);

                if (clazz.isAnnotationPresent(Controller.class)){
                    Controller controller = clazz.getAnnotation(Controller.class);
                    String value = controller.value();
                    String className = clazz.getSimpleName();
                    Object instance = clazz.newInstance();
                    if ("".equals(value)){
                        className = StringUtils.uncapitalize(className);
                    }else {
                        className = value;
                    }
                    ioc.put(className,instance);
                } else if (clazz.isAnnotationPresent(Service.class)) {
                    Service serviceAnnotation = clazz.getAnnotation(Service.class);
                    String annoattionValue = serviceAnnotation.value();
                    Object instance = clazz.newInstance();

                    if ("".equals(annoattionValue)){
                        Class<?>[] interfaces = clazz.getInterfaces();
                        for (Class<?> anInterface : interfaces) {
                            String simpleName = anInterface.getSimpleName();
                            simpleName = StringUtils.uncapitalize(simpleName);
                            ioc.put(simpleName,instance);
                        }

                        //可以通过类名首字母小写
                        String simpleName = clazz.getSimpleName();
                        simpleName = StringUtils.uncapitalize(simpleName);
                        ioc.put(simpleName,instance);

                    }else {
                        ioc.put(annoattionValue,instance);
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

@Autowried 依赖注入

思路

@Autowried注解是用在字段上，通过ioc容器自动装配，因此 @Target(ElementType.FIELD)
需要遍历ioc中所有的 bean 中的所有字段，来进行判断是否需要自动装配
通过反射获取字段，判断该字段是否带有@Autowried 注解，有的话就判断value值
value为"",说明按默认规则用字段类型首字母小写去ioc容器进行查找，如果没有抛出空指针异常throw new NullPointerException("ioc 没有该bean")；
如果有值，去ioc容器进行查找该值对应的bean，如果没有抛出空指针异常throw new NullPointerException("ioc 没有该bean")；如果有该bean，就用该字段的set()方法将本身的bean 和查找ioc获取的bean进行装配
即 declaredField.set(bean, beanInIOC);
由于字段是私有属性private,需要暴力破解declaredField.setAccessible(true);

实现

@Autowried注解是用在字段上，通过ioc容器自动装配，因此 @Target(ElementType.FIELD)

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    String value() default "";
}

需要遍历ioc中所有的 bean 中的所有字段，来进行判断是否需要自动装配
通过反射获取字段，判断该字段是否带有@Autowried 注解，有的话就判断value值
value为"",说明按默认规则用字段类型首字母小写去ioc容器进行查找，如果没有抛出空指针异常throw new NullPointerException("ioc 没有该bean")；
如果有值，去ioc容器进行查找该值对应的bean，如果没有抛出空指针异常throw new NullPointerException("ioc 没有该bean")；如果有该bean，就用该字段的set()方法将本身的bean 和查找ioc获取的bean进行装配
即 declaredField.set(bean, beanInIOC);
由于字段是私有属性private,需要暴力破解declaredField.setAccessible(true);

public void  executeAutoWired(){
    //遍历ioc
    if (ioc.isEmpty()){
        return;
    }

    //获取容器里的所有bean 以及 bean对应的字段
    for (Map.Entry<String, Object> entry : ioc.entrySet()) {
        Object bean = entry.getValue();

        Class<?> clazz = bean.getClass();
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {

            //通过反射获取字段，判断该字段是否带有@Autowried 注解，有的话就判断value值
            if (declaredField.isAnnotationPresent(Autowired.class)){
                Autowired annotation =
                        declaredField.getAnnotation(Autowired.class);
                String beanName = annotation.value();

                try {
                    //value为"",说明按默认规则 用字段类型首字母小写 去ioc容器进行查找，
                    if ("".equals(beanName)){
                        beanName = declaredField.getType().getSimpleName();
                        beanName = StringUtils.uncapitalize(beanName);

                    }
                        Object iocBean = ioc.get(beanName);
                    //如果没有抛出空指针异常
                        if (null == iocBean){
                            throw new NullPointerException("ioc 没有该Bean");
                        }
                        declaredField.setAccessible(true);//暴力破解
                        declaredField.set(bean,iocBean);

                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

@RequestParam

思路

@RequestParam 是写在PARAMETER上的也就是说 @Target(ElementType.PARAMETER)
这个注解实现的功能大方向是分发请求也就是说写在 executeDispatch()方法中的
要实现 @RequestParam 需要将形参列表封装到一个数组中，因为反射 invoke 可以传入一个数组作为可变参数解析
那么就需要两个数组一个数组是新创建的数组（大小应与，目标数组的形参个数一致）将实参放入进去；另一个是反射拿到的目标方法的形参的数组
这两个数组的内容需要一一对应，因为反射需要顺序一致
需要获取到request 中请求的参数Map 获取参数名和参数值
可以将功能具体化到完成这个新数组的实参填写【完成新数组之后放入invoke方法进行反射就行】
将步骤拆解成 1）完成HttpServletRequest 和 HttpServletResponse 的填写；2）完成带有@RequestParam注解的形参的填写；3）完成普通的方法参数没有@RequestParam注解的形参的填写
完成HttpServletRequest 和 HttpServletResponse 的填写：就需要先拿到目标方法的所有参数。根据类型的名称和形参列表进行匹配填写
完成带有@RequestParam注解的形参的填写：需要添加方法，获取目标方法中带有@RequestParam注解的形参是属于第几个参数的，返回int 代表第几个参数，如果有@RequestParam注解，就会返回相应的索引，如果没有就会返回-1 进行普通方法参数的填写处理
普通方法参数的填写：需要添加方法，将目标方法的所有的形参的名称反射保存到 List 返回，再通过遍历判断请求的参数名和 List中一致的填写到数组中
普通方法参数的填写需要插件，使用java8的特性解决在默认情况下 parameter.getName() 获取的名字不是形参真正的名字，而是[arg0,arg1,arg2...]的问题

实现

@RequestParam 是写在PARAMETER上的也就是说 @Target(ElementType.PARAMETER)

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
    String value() default "";
}

这个注解实现的功能大方向是分发请求也就是说写在 executeDispatch()方法中的
要实现 @RequestParam 需要将形参列表封装到一个数组中，因为反射 invoke 可以传入一个数组作为可变参数解析

Method method = zyHandler.getMethod();
Class<?>[] parameterTypes = method.getParameterTypes();//形参数组
Object[] params = new Object[parameterTypes.length];

那么就需要两个数组一个数组是新创建的数组（大小应与，目标数组的形参个数一致）将实参放入进去；另一个是反射拿到的目标方法的形参的数组
这两个数组的内容需要一一对应，因为反射需要顺序一致
需要获取到request 中请求的参数Map 获取参数名和参数值

 request.setCharacterEncoding("utf-8");
 Map<String, String[]> parameterMap = request.getParameterMap();
 for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
    String name = entry.getKey();//参数 键
    String value = entry.getValue()[0];//参数 值

可以将功能具体化到完成这个新数组的实参填写【完成新数组之后放入invoke方法进行反射就行】
将步骤拆解成 1）完成HttpServletRequest 和 HttpServletResponse 的填写；2）完成带有@RequestParam注解的形参的填写；3）完成普通的方法参数没有@RequestParam注解的形参的填写
完成HttpServletRequest 和 HttpServletResponse 的填写：就需要先拿到目标方法的所有参数。根据类型的名称和形参列表进行匹配填写

 for (int i = 0; i < parameterTypes.length; i++) {
                    Class<?> parameterType = parameterTypes[i];
                    if ("HttpServletRequest".equals(parameterType.getSimpleName())) {
                        params[i] = request;
                    } else if ("HttpServletResponse".equals(parameterType.getSimpleName())) {
                        params[i] = response;
                    }
                }

完成带有@RequestParam注解的形参的填写：需要添加方法，获取目标方法中带有@RequestParam注解的形参是属于第几个参数的，返回int 代表第几个参数，如果有@RequestParam注解，就会返回相应的索引，如果没有就会返回-1 进行普通方法参数的填写处理

 //获取目标方法中 带有@RequestParam注解的形参是属于第几个参数的，返
 private int getRequestParamterIndex(Method method,String name){
            Parameter[] parameters = method.getParameters();
            for (int i = 0; i < parameters.length; i++) {
                Parameter parameter = parameters[i];
                if (parameter.isAnnotationPresent(RequestParam.class)) {

                    String value = parameter.getAnnotation(RequestParam.class).value();

                    if (name.equals(value)) {
                        return i;//返回int 代表第几个参数
                    }
                }
        }
        return -1;
    }

int requestParamterIndex = getRequestParamterIndex(zyHandler.getMethod(), name);
                    if (requestParamterIndex != -1) {
                        params[requestParamterIndex] = value;
                    }

普通方法参数的填写：需要添加方法，将目标方法的所有的形参的名称反射保存到 List 返回，再通过遍历判断请求的参数名和 List中一致的填写到数组中

	//将目标方法的所有的形参的名称 反射保存到 List 返回
    private List<String> getParameterNames(Method method){
        List<String> parameterList = new ArrayList<>();

        //获取到所有的参数名称
        Parameter[] parameters = method.getParameters();

        for (Parameter parameter : parameters) {
            //在默认情况下 parameter.getName() 获取的名字不是形参真正的名字
            //而是[arg0,arg1,arg2...]
            //需要插件，使用java8的特性 解决
            String name = parameter.getName();
            parameterList.add(name);
        }
        System.out.println("目标方法的形参列表=" + parameterList);
        return parameterList;
    }

else {
                        //没找到@RequestParam 对应参数--使用默认机制
                        //1. 得到目标方法的所有形参名
                        //2. 对得到目标方法的所有形参名进行遍历，
                        //如果匹配就把当前请求的参数值放入params
                        List<String> parameterNames = getParameterNames(zyHandler.getMethod());
                        for (int i = 0; i < parameterNames.size(); i++) {
                            if (name.equals(parameterNames.get(i))) {
                                params[i] = value;
                                break;
                            }
                        }
                    }

普通方法参数的填写需要插件，使用java8的特性解决在默认情况下 parameter.getName() 获取的名字不是形参真正的名字，而是[arg0,arg1,arg2...]的问题

  <!--可以进行json操作-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.14.0</version>
    </dependency>

完整代码

 public void executeDispatch(HttpServletRequest request, HttpServletResponse response) {
        ZyHandler zyHandler = getZyHandler(request);
        try {
            if (null == zyHandler) {
                response.getWriter().write("<h1>404 NOT FOUND!</h1>");
            } else {
                Method method = zyHandler.getMethod();
                Class<?>[] parameterTypes = method.getParameterTypes();//形参数组
                Object[] params = new Object[parameterTypes.length];


                //遍历 parameterTypes
                //获取 HttpServletRequest , HttpServletResponse 在形参数组中的位置
                //将request 和 response 保存到  params相应的位置上
                for (int i = 0; i < parameterTypes.length; i++) {
                    Class<?> parameterType = parameterTypes[i];
                    if ("HttpServletRequest".equals(parameterType.getSimpleName())) {
                        params[i] = request;
                    } else if ("HttpServletResponse".equals(parameterType.getSimpleName())) {
                        params[i] = response;
                    }
                }

                //获取request中的
                request.setCharacterEncoding("utf-8");
                Map<String, String[]> parameterMap = request.getParameterMap();
                for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
                    String name = entry.getKey();//参数 键
                    String value = entry.getValue()[0];//参数 值

                    //获取形参数组中 带有@RequestParam 的形参 的位置
                    //将带有@RequestParam 保存到  params相应的位置上
                    int requestParamterIndex = getRequestParamterIndex(zyHandler.getMethod(), name);
                    if (requestParamterIndex != -1) {
                        params[requestParamterIndex] = value;
                    } else {
                        //没找到@RequestParam 对应参数--使用默认机制
                        //1. 得到目标方法的所有形参名
                        //2. 对得到目标方法的所有形参名进行遍历，
                        //如果匹配就把当前请求的参数值放入params
                        List<String> parameterNames = getParameterNames(zyHandler.getMethod());
                        for (int i = 0; i < parameterNames.size(); i++) {
                            if (name.equals(parameterNames.get(i))) {
                                params[i] = value;
                                break;
                            }
                        }
                    }
                }

视图解析

思路

首先视图解析它是在分发请求后在目标方法中进行视图的跳转 forward 或者 redirect，所以这部分的代码应该在前端处理器的executeDispatch 中对目标方法进行反射后调用
在对目标方法进行反射 method.invoke() 就会有返回值，根据返回值的类型进行相应业务处理
当返回的是String类型后我们就可以根据 splic（":"）进行分隔
splic（":"）[0] 就是进行跳转的方式 forward 或者 redirect
splic（":"）[1] 就是进行跳转的页面
如果没有":" ，就说明是默认情况，forward 处理即可

实现

首先视图解析它是在分发请求后在目标方法中进行视图的跳转 forward 或者 redirect，所以这部分的代码应该在前端处理器的executeDispatch 中对目标方法进行反射后调用
在对目标方法进行反射 method.invoke() 就会有返回值，根据返回值的类型进行相应业务处理
```
Object result = zyHandler.getMethod().invoke(zyHandler.getController(), params);
```
当返回的是String类型后我们就可以根据 splic（":"）进行分隔
splic（":"）[0] 就是进行跳转的方式 forward 或者 redirect
splic（":"）[1] 就是进行跳转的页面
如果没有":" ，就说明是默认情况，forward 处理即可文章来源地址https://www.toymoban.com/news/detail-856739.html

 if (result instanceof String){
                   String viewName =  (String) result;
                    if (viewName.contains(":")) {
                        String viewType = viewName.split(":")[0];
                        String viewPage = viewName.split(":")[1];

                        if ("forward".equals(viewType)){
                            request.getRequestDispatcher(viewPage).forward(request,response);
                        }else if (("redirect".equals(viewType))){
                            response.sendRedirect(viewPage);
                        }
                    }else {
                        request.getRequestDispatcher(viewName).forward(request,response);
                    }
                }

@ResponseBody 返回JSON数据

实现

首先@ResponseBody 是写在方法上的因此 @Target(ElementType.METHOD)
没有默认值 @ResponseBody仅仅作为一个标识
@ResponseBody它是在分发请求后在目标方法中标识该方法返回JSON格式的数据给浏览器，所以这部分的代码应该在前端处理器的executeDispatch 中对目标方法进行反射后调用
在对目标方法进行反射 method.invoke() 就会有返回值，根据返回值的类型进行相应业务处理
当返回的是一个集合类型，并且判断该方法有注解@ResponseBody ，就说明是需要向浏览器返回JSON格式数据
用jackson 包下的 objectWriter对象的 objectMapper.writeValueAsString（）方法，可以很轻松的将集合转化为JSON进行返回
不要忘了设置response格式，防止乱码，response.setContentType("text/html;charset=utf-8");
直接用response.getWriter.writer()将转化后的结果返回给浏览器即可

思路

首先@ResponseBody 是写在方法上的因此 @Target(ElementType.METHOD)
没有默认值 @ResponseBody仅仅作为一个标识

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseBody {
}

@ResponseBody它是在分发请求后在目标方法中标识该方法返回JSON格式的数据给浏览器，所以这部分的代码应该在前端处理器的executeDispatch 中对目标方法进行反射后调用
在对目标方法进行反射 method.invoke() 就会有返回值，根据返回值的类型进行相应业务处理
当返回的是一个集合类型，并且判断该方法有注解@ResponseBody ，就说明是需要向浏览器返回JSON格式数据
用jackson 包下的 objectWriter对象的 objectMapper.writeValueAsString（）方法，可以很轻松的将集合转化为JSON进行返回

else if (result instanceof ArrayList) {
    if (zyHandler.getMethod().isAnnotationPresent(ResponseBody.class)) {
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(result);
        response.setContentType("text/html;charset=utf-8");
        PrintWriter writer = response.getWriter();
        writer.write(json);
        writer.flush();
        writer.close();
    }
}