手写springmvc

手写springmvc

既然已经手写了spring的IOC，那springmvc肯定也要尝试写写了。手写spring博客:https://www.cnblogs.com/xiaojiesir/p/11139203.html

SpringMVC的运行流程：

（1）首先浏览器发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

（2）DispatcherServlet——>HandlerMapping，处理器映射器将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器对象、多个HandlerInterceptor拦截器）对象；

（3）DispatcherServlet——>HandlerAdapter，处理器适配器将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

（4）HandlerAdapter——>调用处理器相应功能处理方法，并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；

（5）ModelAndView对象（Model部分是业务对象返回的模型数据，View部分为逻辑视图名）——> ViewResolver， 视图解析器将把逻辑视图名解析为具体的View；

（6）View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构；

（7）返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

梳理SpringMVC的设计思路

在没有使用框架前，我们是使用servlet来实现前后端交互的，所以springmvc说到底还是在servlet基础上展开的。如果对servlet不是很熟悉的话，需要先学习下servlet。

框架只是方便开发，底层知识才是最重要的。在掌握底层知识的基础上，再学习框架的设计理念来成长自己。

Servlet 生命周期

Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：

• Servlet 通过调用 init () 方法进行初始化。
• Servlet 调用 service() 方法来处理客户端的请求。
• Servlet 通过调用 destroy() 方法终止（结束）。
• 最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

根据servlet生命周期来看，我们可以在init()方法中初始化基本的beans，并实例化controller层中的定义的service的变量，同时实现映射URL请求的Path和方法。

而service方法我们用doget方法和dopost方法。doPost()主要是实现参数的解析，并通过反射的机制实现方法的调用。

这里只粘贴了部分代码，具体代码可以看下：https://github.com/xiaojiesir/handwritingspringmvc

项目结构

配置web.xml

使用servlet前，我们需要再web.xml中配置以下代码

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
    
  <servlet>
      <servlet-name>mvc</servlet-name>
      <servlet-class>com.springframework.servlet.DispatcherServlet</servlet-class>
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>application.properties</param-value>
      </init-param>
      <!-- Servlet 就会在服务器启动 时执行了。(注意：如果设置为负整数或者不配置，则不会在启动 服务器时执行，而要等此Servlet 被调用时才会被执行。 )-->
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>mvc</servlet-name>
      <url-pattern>/*</url-pattern>
  </servlet-mapping>

</web-app>

<url-pattern>/*</url-pattern> 这种拦截匹配规则其实是一种错误方式，因为只是简易springmvc框架，不需要jsp，所以没问题。具体可以百度了解这方面知识。

实现init方法

    @Override
    public void init(ServletConfig config) throws ServletException {
        System.out.println("init方法");
        //1.加载配置文件
        doLoadCongig(config.getInitParameter(LOCATION));
        //2.扫描所有相关的类
        doScanner(p.getProperty("scanPackage"));
        //3.初始化所有的相关类的实例，并保存到IOC容器中
        doInstance();
        //4.依赖注入
        doAutowired();
        //5.构造HandlerMapping
        initHandlerMapping();
        //6.等待请求，匹配URL，定位方法，反射调用执行
        //调用doGet或者doPost方法
        //提示信息
        System.out.println("my springmvc is success");
    }

init方法中的1.2.3.4可以参考之前手写spring中的代码，我详细讲解下5

第五步遍历容器中的bean，利用@MyRequestMapping注解将url与方法做映射

    private void initHandlerMapping() {
        if (ioc.isEmpty()) {
            return;
        }
        try {
            for (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);
                    System.out.println(url + "," + method);
                }

            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

实现dopost方法

根据请求url，获取method，根据@MyRequestParam注解获取方法参数并赋值，利用反射执行方法

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // TODO Auto-generated method stub
        try {
            System.out.println("doPost");
            doDispatch(req,resp);//未采用策略模式
            //doDispatchDesignPatterns(req,resp);//采用策略模式
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
}

未采用策略模式，参数类型使用if else if判断类型，

    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
        // TODO Auto-generated method stub
        if(this.handlerMapping.isEmpty()){
            return;
        }
        String url =req.getRequestURI();//   /myspringmvc/demo/user
        String contextPath = req.getContextPath();//   /myspringmvc
        url = url.replace(contextPath, "").replaceAll("/+", "/");
        if(!this.handlerMapping.containsKey(url)){
            resp.getWriter().write("404 Not Found!!");
            return;
        }
        Map<String,String[]> params = req.getParameterMap();
        Method method =this.handlerMapping.get(url);
        //获取方法的参数列表
        Class<?>[] paramerterTypes = method.getParameterTypes();
        //获取请求的参数
        Map<String,String[]> parameterMap  = req.getParameterMap();
        //保留参数值
        Object[] paramValues = new Object[paramerterTypes.length];
        //方法的参数列表
        for (int i = 0; i < paramerterTypes.length; i++) {
            //根据参数名称，做某些处理
            Class parameterType =paramerterTypes[i];
            if(parameterType == HttpServletRequest.class){
                //参数类型已明确，这边强转类型
                paramValues[i] =req;
                continue;
            }else if(parameterType == HttpServletResponse.class){
                paramValues[i] = resp;
                continue;
            }else if(parameterType == String.class){
                //获取当前方法的参数
                Annotation[][] an = method.getParameterAnnotations();//个数和paramerterTypes.length一样
                Annotation[] paramAns = an[i];
                
                for (Annotation paramAn : paramAns) {
                    //判断传进的paramAn.getClass()是不是 MyRequestParam 类型
                    if (MyRequestParam.class.isAssignableFrom(paramAn.getClass())) {
                        MyRequestParam cr = (MyRequestParam) paramAn;
                        String value = cr.value();
                        paramValues[i] = req.getParameter(value);
                    }
                }
            }
            
        }
        try {
            //String beanName = lowerFirstCase(method.getDeclaringClass().getSimpleName());//获取源代码中给出的‘底层类’简称
            String beanName = "/" + url.split("/")[1];
            method.invoke(this.ioc.get(beanName), paramValues);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        
     }

采用策略模式

    private void doDispatchDesignPatterns(HttpServletRequest req, HttpServletResponse resp) {
        // 通过req获取请求的url /myspringmvc/demo/user
            String url = req.getRequestURI();
            // /myspringmvc
            String context = req.getContextPath();
            // /demo/user
            String path = url.replaceAll(context, "");
            
            // 通过当前的path获取handlerMap的方法名
            Method method = this.handlerMapping.get(path);
            // 获取beans容器中的bean
            Object instance = this.ioc.get("/" + path.split("/")[1]);// 处理参数
            HandlerAdapterService ha = (HandlerAdapterService) this.ioc.get("myHandlerAdapter"); 
            Object[] args = ha.handle(req, resp, method, ioc);
            
            // 通过反射来实现方法的调用
            try {
                method.invoke(instance, args);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

    }

处理参数接口

package com.xiaojiesir.demo.handlerAdapter;

import java.lang.reflect.Method;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface HandlerAdapterService {

    public Object[] handle(HttpServletRequest req, HttpServletResponse resp,
            Method method, Map<String, Object> beans);
}

处理参数的实现类

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.springframework.annotation.MyService;
import com.xiaojiesir.demo.argumentResolver.ArgumentResolver;

@MyService("myHandlerAdapter")
public class MyHandlerAdapter implements HandlerAdapterService {

    @Override
    public Object[] handle(HttpServletRequest req, HttpServletResponse resp, Method method, Map<String, Object> beans) {
        // TODO Auto-generated method stub
        //获取方法中含义的参数
                Class<?>[] paramClazzs = method.getParameterTypes();
                System.out.println("======当前需要解析的参数对应的类=========");
                for(Class<?> clazz: paramClazzs) {
                    System.out.println(clazz);
                }
                
                // 定义一个返回参数的结果集
                Object[] args = new Object[paramClazzs.length];
//                Object[] args = {req, resp, "name", "xiaojiesir"};
                
                // 定义一个ArgumentResolver实现类的Map
                Map<String, Object> argumentResolvers = getBeansOfType(beans, ArgumentResolver.class);
                System.out.println("======当前需要解析的参数对应的类实例化=========");
                for(Map.Entry<String, Object> map: argumentResolvers.entrySet()) {
                    System.out.println("key:" + map.getKey() + "; value:" + map.getValue());
                }
                
                //定义参数索引
                int paramIndex = 0;
                //定义数组下标索引
                int i = 0; 
                // 开始处理参数
                for(Class<?> paramClazz: paramClazzs) {
                    //哪个参数对应了哪个参数解析类,用策略模式来找
                    for (Map.Entry<String, Object> entry : argumentResolvers.entrySet()) {
                        ArgumentResolver ar = (ArgumentResolver)entry.getValue();
                        
                        if (ar.support(paramClazz, paramIndex, method)) {
                            args[i++] = ar.argumentResolver(req,
                                    resp,
                                    paramClazz,
                                    paramIndex,
                                    method);
                        }
                    }
                    paramIndex++;
                }
                
                return args;
            }
         
            /**
             * @param beans IOC容器中全部的bean
             * @param intfType 定义的ArgumentResolver类
             * @return
             */
            private Map<String, Object> getBeansOfType(Map<String, Object> beans,
                    Class<ArgumentResolver> intfType) {
                Map<String, Object> resultBeans = new HashMap<>();
                for(Map.Entry<String, Object> map: beans.entrySet()) {
                    // 获取满足ArgumentResolver接口的bean
                    Class<?>[] intfs = map.getValue().getClass().getInterfaces();
                    if(intfs != null && intfs.length >0) {
                        for(Class<?> intf: intfs) {
                            // 将满足的bean存储在resultBeans中
                            if(intf.isAssignableFrom(intfType)) {
                                resultBeans.put(map.getKey(), map.getValue());
                            }
                        }
                    }
                }
                return resultBeans;
            }

    }

参数接口

import java.lang.reflect.Method;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface ArgumentResolver {
    /**
     * 判断当前的类是继承于ArgumentResolver
     * @param type 当前参数注解的类对象
     * @param paramIndex 参数下标
     * @param method 当前的方法
     * @return
     */
    public boolean support(Class<?> type, int paramIndex, Method method);
    
    /**
     * 
     * @param request
     * @param response
     * @param type
     * @param paramIndex
     * @param method
     * @return
     */
    public Object argumentResolver(HttpServletRequest request,
                HttpServletResponse response, Class<?> type, 
                int paramIndex,
                Method method);
}

处理Request请求参数

import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.springframework.annotation.MyService;

/*
 * 处理Request请求参数
 */
@MyService("httpServletRequestArgumentResolver")
public class HttpServletRequestArgumentResolver implements ArgumentResolver {
     
    @Override
    public boolean support(Class<?> type, int paramIndex, Method method) {
        return ServletRequest.class.isAssignableFrom(type);
    }
 
    @Override
    public Object argumentResolver(HttpServletRequest request,
            HttpServletResponse response, Class<?> type, int paramIndex,
            Method method) {
        return request;
    }
 
}

处理Response参数

import java.lang.reflect.Method;

import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.springframework.annotation.MyService;
/*
 * 处理Response参数
 */
@MyService("httpServletResponseArgumentResolver")
public class HttpServletResponseArgumentResolver implements ArgumentResolver {
 
    @Override
    public boolean support(Class<?> type, int paramIndex, Method method) {
        return ServletResponse.class.isAssignableFrom(type);
    }
 
    @Override
    public Object argumentResolver(HttpServletRequest request,
            HttpServletResponse response, Class<?> type, int paramIndex,
            Method method) {
        return response;
    }
 
}

处理自定义的参数

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.springframework.annotation.MyRequestParam;
import com.springframework.annotation.MyService;

@MyService("requestParamArgumentResolver")
public class RequestParamArgumentResolver implements ArgumentResolver {
 
    @Override
    public boolean support(Class<?> type, int paramIndex, Method method) {
        // type = class java.lang.String
        // @MyRequestParam("name")String name
        //获取当前方法的参数
        Annotation[][] an = method.getParameterAnnotations();
        Annotation[] paramAns = an[paramIndex];
        
        for (Annotation paramAn : paramAns) {
            //判断传进的paramAn.getClass()是不是 MyRequestParam 类型
            if (MyRequestParam.class.isAssignableFrom(paramAn.getClass())) {
                return true;
            }
        }
        
        return false;
    }
 
    @Override
    public Object argumentResolver(HttpServletRequest request,
            HttpServletResponse response, Class<?> type, int paramIndex,
            Method method) {
        
        //获取当前方法的参数
        Annotation[][] an = method.getParameterAnnotations();
        Annotation[] paramAns = an[paramIndex];
        
        for (Annotation paramAn : paramAns) {
            //判断传进的paramAn.getClass()是不是 MyRequestParam 类型
            if (MyRequestParam.class.isAssignableFrom(paramAn.getClass())) {
                MyRequestParam cr = (MyRequestParam) paramAn;
                String value = cr.value();
                return request.getParameter(value);
            }
        }
        return null;
    }
 
}

启动服务，在URL输入请求地址：

http://localhost:8080/myspringmvc/demo/user?name=xiaojiesir123&id=1

 

总结：

手写的spring和springmvc主要用了反射、注解。正式的spring中还有很多设计模式，值得我们学习。所以我们在掌握基础知识后，多读框架的源码，获取框架中的设计模式，设计理念更助于提升自己。