概念

• 过滤器(Filter)

  过滤器依赖于Servlet容器。在实现上，基于函数回调，它可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的，是用来做一些过滤操作，获取我们想要的数据，比如：JavaWeb中对传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者Controller进行业务逻辑操作。

  通常适用场景：修改字符编码(CharacterEncodingFilter)、过滤HttpServletRequest中敏感字符(XSSFilter自定义过滤器)

• 拦截器(Interceptor)

  拦截器依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上，基于Java的反射机制，属于面向切面编程(AOP)的一种运用，就是在Service或者一个方法前调用一个方法，或者在方法后调用一个方法，甚至在抛出异常的时候做业务逻辑的操作，比如动态代理就是拦截器的简单实现。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入(DI)进行一些业务操作，同时一个拦截器实例在一个Controller生命周期之内可以多次调用。但缺点是只能对Controller请求进行拦截，也可以拦截静态资源，必须要添加上配置才可以避免静态资源被拦截，拦截器不能拦截的只有jsp。

源码

过滤器(Filter)

• 源码

  @Overridepublic void init(FilterConfig arg0) throws ServletException {}@Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {System.out.println("before...");chain.doFilter(request, response);System.out.println("after...");}@Overridepublic void destroy() {}

• 源码分析

拦截器(Interceptor)

• 源码

  @Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("preHandle");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("postHandle");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("afterCompletion");}

• 源码分析

区别详解

配置方式

• 过滤器

  1. 配置web.xml，设置字符编码防止乱码

     <filter><filter-name>encoding</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>encoding</filter-name><servlet-name>/*</servlet-name></filter-mapping>

• 拦截器

  1. 配置在SpringMVC配置文件中，使用Interceptors标签

     <mvc:interceptors><mvc:interceptor><mvc:mapping path="/**" /><bean class="com.scorpios.atcrowdfunding.web.LoginInterceptor"></bean></mvc:interceptor><mvc:interceptor><mvc:mapping path="/**" /><bean class="com.scorpios.atcrowdfunding.web.AuthInterceptor"></bean></mvc:interceptor></mvc:interceptors>

执行顺序

• 执行顺序

  过滤前-----拦截前-----Action处理-----拦截后-----过滤后

• 层级关系

  拦截器是被包裹在过滤器之中

  

• 执行流程
  

• 执行顺序分析

  1. preHandle()这个方法是在过滤器的chain.doFilter(request, response)方法的前一步执行，也就是在 [System.out.println(“before…”)][chain.doFilter(request, response)]之间执行。

  2. postHandle方法是在preHandle()方法之后，在return ModelAndView之前进行，可以操控Controller的ModelAndView内容。

  3. afterCompletion()方法是在过滤器返回给前端前一步执行，也就是在[chain.doFilter(request, response)][System.out.println(“after…”)]之间执行。

多个过滤器和拦截器样例执行顺序分析

过滤器

• 第一个过滤器

  public class TestFilter1 implements Filter {  @Overrideprotected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {  //在DispatcherServlet之前执行  System.out.println("############TestFilter1 doFilterInternal executed############");  filterChain.doFilter(request, response);  //在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后  System.out.println("############TestFilter1 doFilter after############");  }  }  

• 第二个过滤器

  public class TestFilter2 implements Filter {  @Overrideprotected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {  //在DispatcherServlet之前执行  System.out.println("############TestFilter2 doFilterInternal executed############");  filterChain.doFilter(request, response);  //在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后 System.out.println("############TestFilter2 doFilter after############");  }  }  

• web.xml中注册过滤器

  <!-- 自定义过滤器：testFilter1 -->   <filter>  <filter-name>testFilter1</filter-name>  <filter-class>com.scorpios.filter.TestFilter1</filter-class>  </filter>  <filter-mapping>  <filter-name>testFilter1</filter-name>  <url-pattern>/*</url-pattern>  </filter-mapping>  <!-- 自定义过滤器：testFilter2 -->   <filter>  <filter-name>testFilter2</filter-name>  <filter-class>com.scorpios.filter.TestFilter2</filter-class>  </filter>  <filter-mapping>  <filter-name>testFilter2</filter-name>  <url-pattern>/*</url-pattern>  </filter-mapping>  

拦截器

• 第一个拦截器

  public class BaseInterceptor implements HandlerInterceptor{  /** * 在DispatcherServlet之前执行 * */  public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  System.out.println("************BaseInterceptor preHandle executed**********");  return true;  }  /** * 在controller执行之后的DispatcherServlet之后执行 * */  public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  System.out.println("************BaseInterceptor postHandle executed**********");  }  /** * 在页面渲染完成返回给客户端之前执行 * */  public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)  throws Exception {  System.out.println("************BaseInterceptor afterCompletion executed**********");  }  }  

• 第二个拦截器

  public class TestInterceptor implements HandlerInterceptor {  public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  System.out.println("************TestInterceptor preHandle executed**********");  return true;  }  public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  System.out.println("************TestInterceptor postHandle executed**********");  }  public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {  System.out.println("************TestInterceptor afterCompletion executed**********");  }  }  

• SpringMVC配置文件中注册拦截器

  <!-- 拦截器 -->  <mvc:interceptors>  <!-- 对所有请求都拦截，公共拦截器可以有多个 -->  <bean name="baseInterceptor" class="com.scorpios.interceptor.BaseInterceptor" />  <mvc:interceptor> <!-- 对/test.html进行拦截 -->       <mvc:mapping path="/test.html"/>  <!-- 特定请求的拦截器只能有一个 -->  <bean class="com.scorpios.interceptor.TestInterceptor" />  </mvc:interceptor>  </mvc:interceptors>  

其他

• Controller控制器

  package com.scorpios.controller;  import org.springframework.stereotype.Controller;  import org.springframework.web.bind.annotation.RequestMapping;  import org.springframework.web.servlet.ModelAndView;  @Controller  public class TestController {  @RequestMapping("/test")  public ModelAndView handleRequest(){  System.out.println("---------TestController executed--------");  return new ModelAndView("test");  }  }  

• 测试结果

  1. 启动测试项目，访问地址如下：http://www.localhost:8080/demo

  ############TestFilter1 doFilterInternal executed########################TestFilter2 doFilterInternal executed########################TestFilter2 doFilter after########################TestFilter1 doFilter after############

  结果分析：这就说明了过滤器的运行是依赖于servlet容器，跟springmvc等框架并没有关系。并且，多个过滤器的执行顺序跟xml文件中定义的先后关系有关

  2. 并访问：http://www.localhost:8080/demo/test
     

  结果分析：拦截器依赖于Spring框架，且过滤器在拦截器执行之前执行，多个过滤器的执行顺序跟xml文件中定义的先后关系有关。

• 总体执行结果
  

注意事项

• 过滤器

  1. 过滤器是在请求进入容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前。

  2. 过滤器的触发时机是容器后，servlet之前，所以过滤器doFilter方法入参是ServletRequest，而不是HttpServletRequest。因为过滤器是在HttpServlet之前。

     @Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {System.out.println("before...");chain.doFilter(request, response);System.out.println("after...");}

  3. chain.doFilter(request, response)这个方法的调用作为分水岭。事实上调用Servlet的doService()方法是在chain.doFilter(request, response)方法中进行的

  4. SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller，其实这一步是在Servlet的service()方法中执行的。

• 拦截器

  1. 拦截器是Spring容器的一个的组件，归Spring管理，配置在Spring文件中，因此能使用Spring里的任何资源、对象，例如Service对象、数据源、事务管理等，通过IOC注入到拦截器即可

总结

• 区别

  1. 原理：拦截器是基于java的反射机制的，而过滤器是基于函数回调

  2. 规范：拦截器是Spring容器内的，是Spring框架支持的；过滤器则不能，因为其依赖于servlet容器，是在Servlet规范中定义的

  3. 使用范围：拦截器既可以用于Web程序中，也可以用于Application、Swing程序中；过滤器只能用于Web程序中

  4. 作用范围：拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用

  5. 访问范围：拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问

  6. 调用频率：在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次

  7. 拦截器可以获取IOC容器中的各个bean(基于FactoryBean接口)，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑

  8. 多个执行顺序：拦截器按照配置的顺序，但是可以通过order控制顺序；过滤器根据filter mapping配置的先后顺序

  9. 深度：拦截器能够深入到方法前后、异常抛出前后等，因此拦截器的使用具有更大的弹性；而Filter在只在Servlet前后起作用。所以在Spring构架的程序中，要优先使用拦截器。

• 例图
  

参考链接

https://blog.csdn.net/zxd1435513775/article/details/80556034
https://www.cnblogs.com/panxuejun/p/7715917.html