SpringMvc拦截器和手写模拟SpringMvc工作流程源码详解

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分。
M: Model，模型层，指工程中的JavaBean，作用是处理数据。
JavaBean分为两类：
1.实体类Bean:专门存储业务数据的，如Student User等
2.业务处理Bean:指Service或Dao对象，专门用于处理业务逻辑和数据访问。
V: View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据。
C: Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器。
MVC的工作流程:
用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器。

1.2 什么是SpringMvc

SpringMVC是Spring的一个后续产品，是Spring的一个子项目。
SpringMVC是Spring为表述层开发提供的一整套完备的解决方案。在表述层框架历经Strust、WebWork,Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC作为JavaEE项目表述层开发的首选方案。

SpringMVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，帮助我们简化开发。

1.3 SpringMvc 能干什么

　 1）天生与Spring框架集成，如：(IOC,AOP)

　　2）支持Restful风格

　　3）进行更简洁的Web层开发

　　4）支持灵活的URL到页面控制器的映射

　　5）非常容易与其他视图技术集成，如:Velocity、FreeMarker等等

　　6）因为模型数据不存放在特定的API里，而是放在一个Model里(Map数据结构实现，因此很容易被其他框架使用)

　　7）非常灵活的数据验证、格式化和数据绑定机制、能使用任何对象进行数据绑定，不必实现特定框架的API

　　8）更加简单、强大的异常处理

　　9）对静态资源的支持

　 10）支持灵活的本地化、主题等解析

1.4 SpringMvc 工作流程

SpringMvc工作流程如下图：

具体步骤：

第一步：发起请求到前端控制器DispatcherServlet。
第二步：前端控制器DispatcherServlet收到请求后调用处理器映射器HandlerMapping。
第三步：处理器映射器HandlerMapping 根据请求的URL找到具体的处理器，生成处理器对象Handler 以及处理器拦截器HandlerIntercepter(如果有则生成)，并返回给向前端控制器。
第四步：前端控制器DispatcherServlet通过处理器适配器HandlerAdapter去调用处理器Controller。
第五步：调用处理器（Controller,也叫控制器）。
第六步：处理器Controller执行完成给适配器返回ModelAndView
第七步：处理器适配器HandleAdapter将处理器Controller返回的结果ModelAndView返回给前端控制器DispatcherServlet。
第八步：前端控制器DispatcherServlet将ModelAndView传给视图解析器ViewResolver。
第九步：视图解析器ViewResolver解析后向前端控制器DispatcherServlet返回View。
第十步：前端控制器DispatcherServlet进行视图渲染（视图渲染将模型数据(在ModelAndView对象中)填充到request域）。
第十一步：前端控制器DispatcherServlet向用户响应结果。

2. SpringMvc拦截器和过滤器

2.1 拦截器

2.1.1 拦截器作用

SpringMVC的拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理
将拦截器按一定的顺序连接成链，这条链称为拦截器链（Interceptor chain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

2.1.2 拦截器和过滤器的区别

如下图：

2.1.3 拦截器方法说明

Spring MVC也可以使用拦截器对请求进行拦截处理，用户可以自定义拦截器来实现特定的功能，自定义的拦截器可以实现HandlerInterceptor接口，也可以继承HandlerInterceptorAdapter 适配器类。

① preHandle()：这个方法在业务处理器处理请求之前被调用，在该方法中对用户请求 request 进行处理。如果程序员决定该拦截器对请求进行拦截处理后还要调用其他的拦截器，或者是业务处理器去进行处理，则返回true；如果程序员决定不需要再调用其他的组件去处理请求，则返回false。

② postHandle()：这个方法在业务处理器处理完请求后，但是DispatcherServlet 向客户端返回响应前被调用，在该方法中对用户请求request进行处理。

③ afterCompletion()：这个方法在 DispatcherServlet 完全处理完请求后被调用，可以在该方法中进行一些资源清理的操作。

2.1.4 多个拦截器执行顺序

2.1.5 自定义拦截器

自定义拦截器步骤如下：

①创建拦截器类实现HandlerInterceptor接口

②配置拦截器

③测试拦截器的拦截效果

这里采用Springboot框架，代码如下：

创建拦截器类实现HandlerInterceptor接口

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("token");
        System.out.println("执行了preHandle方法");
        if(token.equals("admin"))
            return true;
        else
            return false;

    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("执行了postHandle方法");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("执行了afterCompletion方法");
    }
}

配置拦截器

@Configuration
public class MyConfiguration implements WebMvcConfigurer {


    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/test1");
    }
}

2.2 过滤器（附加）

过滤器是Web开发中很实用的一项技术，开发人员可以通过过滤器对Web服务管理的资源静态HTML文件、静态图片、JSP、 Servlet 等进行拦截，从而实现一一些特殊的需求，比如设置URL的访问权限、过滤敏感词汇、压缩响应信息等。过滤器还适用于对用户请求和响应对象进行检查和修改，但是Filter本身并不生成请求和响应对象，只是提供过滤功能。Filter 的完整工作流程如图所示：

当客户瑞发出对Web资源的请求时，Web服务器会根据应用程序配置文件设置的过滤规则进行检查，若客户端请求满足过滤规则，则对客户端请求响应进行拦截。首先按照需求对请求头和请求数据进行封装，并依次通过过滤器链，然后把请求/响应交给Web资源处理，请求信息在过滤器链中可以被修改，也可以根据条件让请求不发往资源处理器，并直接向客户机发回一个响应。当资源处理器完成了对资源的处理后，响应信息将逐级逆向返回。在这个过程中，用户可以修改响应信息，从而完成一定的任务。这就是过滤器的工作原理。

另外，过滤器的生命周期也是由Web服务器进行负责的，但是相比真正的Servlet又有区别。Filter 的生命周期大致分为以下三个阶段:

(1)实例化: Web容器在部署Web应用程序时对所有过滤器进行实例化，此时Web容器调用的是它的无参构造方法。

(2)初始化:实例化完成之后，马上进行初始化工作。Web容器回调initO方法。请求路径匹配过滤器的URL映射时，Web容器回调过滤器的doFilter()方法，此方法也是过滤器的核心方法。

3)销毁: Web容器在卸载Web应用程序前回调doDestory 方法。

在Springboot中要在启动类上加上@ServletComponentScan注解

过滤器代码如下：

@WebFilter("/*")
public class WebTestFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("过滤器前进");
        chain.doFilter(request,response);
        System.out.println("过滤器返回");
    }

    @Override
    public void destroy() {

    }
}

注意：在Controller业务处理中，如果有请求的转发，拦截器会拦截多次，而过滤器并不会。

3. 手写模拟SpringMvc源码

3.1 目录结构如下

3.2 导入依赖

 <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
    <!--       解析xml文件-->
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.9</version>
    </dependency>

3.3 分析

在启动Tomcat后，会自动解析webapp中的WEB-INF中的web.xml，所以我们在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>Application</display-name>

  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>com.example.demo.springmvc.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

这里的DispatcherServlet为我们自己创建的类。当Tomcat启动后，就会解析Web.xml文件，并且创建我们自定义的DispatcherServlet类。在上面目录中我们创建了ApplicationContext类，这里相当于Spring容器，这块的代码属于Spring源码部分，在这里省略。然后就会执行DispatcherServlet类中的init()方法，该方法作用为创建Spring容器，从Springmvc.xml文件中读取base-package中的包路径，这里Spring容器会扫描这里的包路径并且生成Controller类型的Bean对象，init方法代码如下：

private ApplicationContext applicationContext; //Spring容器
 

    @Override
    public void init() throws ServletException {
        String contextConfigLocation = this.getServletConfig().getInitParameter("contextConfigLocation"); //这里获取Web.xml文件中的contextConfigLocation参数，这里为classpath:springmvc.xml。
        applicationContext = new ApplicationContext(contextConfigLocation);//这里为创建Spring容器，从Springmvc.xml文件中读取base-package中的包路径，这里Spring容器会扫描这里的包路径并且生成Controller类型的Bean.
        applicationContext.refresh();
        initHandleMappinng(applicationContext);

    }

Spring容器将Spring.xml文件中的包路径下的Controller生成Bean对象后，执行DispatcherServlet中的initHandleMappinng方法，该方法会遍历Spring容器中beanDefinitionConcurrentHashMap，遍历其中的所有的Controller类型的Bean对象的Class对象，然后判断每一个Class对象中的所有方法，将有@RequestMapping注解的方法，进行封装成一个MyHandle对象，其中包含@RequestMapping注解的Value值，该方法名，Class对象等，然后将这个MyHandle对象放到集合中。代码如下：

  public void initHandleMappinng(ApplicationContext applicationContext){
        if(applicationContext.beanDefinitionConcurrentHashMap.size()==0){
            throw new RuntimeException("Spring容器为空");
        }
        for (Map.Entry<String, BeanDefinition> stringBeanDefinitionEntry : applicationContext.beanDefinitionConcurrentHashMap.entrySet()) {
            Class clazz = stringBeanDefinitionEntry.getValue().getClazz();
            for (Method declaredMethod : clazz.getDeclaredMethods()) {
                boolean annotationPresent = declaredMethod.isAnnotationPresent(RequestMapping.class);
                if(annotationPresent==true){
                    String value = declaredMethod.getAnnotation(RequestMapping.class).value();
                    MyHandle myHandle=new MyHandle(value,declaredMethod,clazz);
                    myHandleList.add(myHandle);
                }
            }
        }
    }

当有get请求的时候就会执行DispatcherServlet中的doGet方法，然后我们的业务逻辑如下：在这里我们会遍历我们存放MyHandle对象的集合中的元素，寻找浏览器url请求路径和我们MyHandle对象中储存的@RequestMapping中相等的对象，然后设置个Object数组，经过一系列的关于@RequestParam参数的判断，将浏览器请求路径中的参数放到对应位置的Object数组中，然后通过method.invoke执行这个方法就可以执行我们的方法并获得返回值，然后我们就可以通过PrintWriter writer = response.getWriter(); writer.print(); 将返回的数据打印到浏览器上。代码如下：

public void excuteDispatch(HttpServletRequest request,HttpServletResponse response){
        MyHandle handle = getHandle(request);
        if(handle==null){
            try {
                response.getWriter().print("404");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        else {
            Method method = handle.getMethod();
            Class<?>[] parameterTypes = method.getParameterTypes();
            Object[] params=new Object[parameterTypes.length];
            Map<String, String[]> parameterMap = request.getParameterMap();
            for (Map.Entry<String, String[]> stringEntry : parameterMap.entrySet()) {
                String key = stringEntry.getKey();
                String value = stringEntry.getValue()[0];
                int i = GetRequestParams(method, key);
                if(i>=0)
                    params[i]=value;
                else {
                    //反射获取的是arg0，官方这里用的不是反射机制
                }
            }
            try {
                Object invoke = method.invoke(handle.getClazz().newInstance(), params);
                PrintWriter writer = response.getWriter();
                writer.print(invoke);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

其余的代码省略，全部代码可以下载我的文件资源进行查看。

3.4 测试

我们自己模拟写了一个简单的SpringMvc框架，启动Tomcat后然后我们进行验证如下：

测试代码如下：

@Controller("mycontroller")
public class MyController {

    @RequestMapping("/test")
    public String test(@RequestParam("name") String name, HttpServletResponse response){
        return name;
    }
}

运行结果如下图：