过滤器、拦截器、aop的先后顺序和作用范围&拦截器preHandle(),postHandle(),afterComplation()方法执行顺序

过滤器、拦截器、aop的 先后顺序和作用范围

在Spring框架中，过滤器（Filter）、拦截器（Interceptor）和面向切面编程（AOP）都是用于处理请求和处理流程的组件，但它们的作用范围和触发时机有所不同。下面我会解释这三者的先后顺序和作用范围。

1. 过滤器（Filter）
   • 过滤器是Servlet规范中的一部分，它在Spring框架之外，由Servlet容器（如Tomcat）管理。
   • 过滤器在请求到达Servlet之前执行，并且可以在响应返回给客户端之前执行。
   • 过滤器通常用于执行一些跨多个请求和响应的任务，如日志记录、身份验证、编码转换等。
   • 过滤器通过实现javax.servlet.Filter接口来定义。
2. 拦截器（Interceptor）
   • 拦截器是Spring框架的一部分，它依赖于Spring的AOP模块。
   • 拦截器在Spring的DispatcherServlet中工作，用于拦截请求并在控制器之前或之后执行。
   • 拦截器通常用于记录日志、执行安全检查、数据绑定等操作。
   • 拦截器通过实现org.springframework.web.servlet.HandlerInterceptor接口或扩展org.springframework.web.servlet.handler.HandlerInterceptorAdapter类来定义。
3. AOP（面向切面编程）
   • AOP是Spring框架中的一个重要特性，它允许开发者定义横切关注点（cross-cutting concerns），这些关注点通常与业务逻辑无关，如日志、事务管理等。
   • AOP通过代理模式在运行时织入切面（Aspect）到目标对象中，从而在不修改业务逻辑代码的情况下增强功能。
   • AOP的切点（Pointcut）可以定义在方法执行之前、之后或异常抛出时触发。
   • AOP通过实现org.aspectj.lang.annotation.Aspect接口并使用@Aspect、@Pointcut、@Before、@After、@AfterReturning、@AfterThrowing等注解来定义。

执行顺序：

• 首先，请求到达Servlet容器，触发过滤器（Filter）。
• 然后，请求被DispatcherServlet捕获，触发拦截器（Interceptor）。
• 接着，如果定义了AOP切面，它们会在相应的时机（如方法执行前或后）被触发。
• 最后，请求到达控制器（Controller），执行相应的业务逻辑。

请注意，这个顺序可能因具体的配置和使用的技术而有所不同。在实际应用中，建议根据项目的具体需求来合理配置和使用这些组件。

拦截器的执行时机和原理

拦截器原理

1. 根据当前请求，找到HandlerExecutionChain执行链，执行链可以处理当前请求的handler方法以及handler方法的所有拦截器
   
2. 先来顺序执行所有拦截器的preHandle方法
   （1）如果当前拦截器preHandle返回为true，说明放行，则执行下一个拦截器的preHandle方法
   （2）如果当前拦截器preHandle返回为false，说明不放行，则倒序执行所有已经执行了的拦截器的afterCompletion
3. 如果任何一个拦截器返回false，就直接跳出，不会执行目标方法
4. 所有拦截器都返回true才会执行目标方法
5. 倒序执行所有拦截器的postHandle方法
6. 之前的所有步骤如果有任何异常就不会继续向下执行，但都会直接倒序触发afterCompletion
7. 如何没有任何异常，页面成功渲染完成以后，也会倒序触发afterCompletion方法

拦截器执行流程图：

SpringMVC中拦截器执行时机和执行顺序分析

1. 拦截器的作用时机

• 和过滤器一样，拦截器也可以拦截请求。
• 过滤器是在DispatcherServlet处理之前拦截，拦截器是在DispatcherServlet处理请求然后调用控制器方法(即我们自己写的处理请求的方法，用@RequestMapping标注)之前进行拦截。

2. 拦截器的三个默认方法

• 实现拦截器需要实现HandlerInterceptor这个接口，这个 接口中有三个默认方法，这三个方法的执行顺序：

  • preHandle：控制器方法执行之前执行preHandle()，返回值是一个boolean，表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法
  • postHandle：控制器方法执行之后执行postHandle()
  • afterComplation：处理完视图和模型数据，渲染视图完毕之后执行afterComplation()

• 我们实现接口然后重写这三个方法，就会在对应的时机被自动执行。

3. 分析拦截器方法执行时机

3.1 preHandle()和postHandle()执行时机

• 在处理请求的时候会调用DispatcherServlet，这里面有如下代码:

• mv=ha.handle()这里就是调用处理请求的方法，返回值是一个ModelAndView类型的对象。

• 上图这里可以看见在mv=ha.handle()之前和之后调用了applayPreHandle()和applyPostHandle()两个方法。这两个方法就是执行所有拦截器的preHandle()方法和postHandle()方法。因此可以看见在处理请求之前执行preHandle()，处理请求之后执行postHandle()。

• 上图的mappedHandler是一个处理执行链，类型为HandlerExecutionChain

  • 这个对象包含三个属性，如下图所示：

    • 第一个handler表示当前请求对应的控制器方法；
    • 第二个表示当前请求对应的所有拦截器集合，可以看见第一个是自带的拦截器，第二个是我们配置的；
    • 第三个表示的是applyPreHandle()这个方法执行完后最后一个PreHandle()方法返回ture的拦截器的索引。
    • 

• 既然有拦截就要有放行，拦截器的三个方法中要想要进行拦截肯定得在处理器方法执行之前，即只有PreHandle()方法会进行拦截然后判断是否放行。看下三个方法的源码，只有PreHandle()方法有返回值，返回true代表放行，false代表不放行：

  

• 这里调用applyPreHandler()方法的源码：

  boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
      //这里循环遍历所有的interceptor,按顺序遍历，这个顺序就是我们在配置文件中配置的顺序，除了我们配置的还有一个自带的，
      //这个拦截器是第一个生效的，索引是0
      //for循环的第三个表示将每个返回true的拦截器的索引,赋值给interceptorIndex属性,然后再让索引自增，即interceptorIndex记录的就是
      //这个applyPreHandeler()方法执行完后最后一个放行的拦截器的索引
      for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
          HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
          //这里会调用每一个interceptor的preHandle方法，然后如果返回false表示不放行
          if (!interceptor.preHandle(request, response, this.handler)) {
              this.triggerAfterCompletion(request, response, (Exception)null);
              return false;
          }
      }
  
      return true;
  }
  

  • 如果preHandle()返回false则进入if语句，里面同样会返回false，然后返回到上一层调用的地方：
    

    • 这里是false则进入if语句，直接retrun，因此不会执行下面的控制器方法，这就意味着preHandle()返回false代表不放行。

3.2 afterComplation方法执行时机

• 在DispatcherServlet中有如下代码：
• 
• • 这里的this.render()方法就是渲染视图的，在这个方法下面调用了treggerAfterCompletion()方法，这个方法会调用不放行的那个拦截器之前的所有拦截器的afterComplation方法。因此在渲染视图之后调用afterComplation。
  • 但是如果前面的PreHandle方法如果不放行，则执行不到这里，但是前面的applyPreHandler()方法中会在不放行的时候自己调用treggerAfterCompletion()方法，因此放行和不放行执行treggerAfterCompletion()方法的地方不是同一个。

4. 多个拦截器时每个方法的执行顺序

• 若每个拦截器的preHandle()都返回true
  • 此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：
  • preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行

4.1 分析顺序执行和反序执行

这里看源码：

preHandle

• 这里调用所有拦截器的preHandle()方法：

  

  • 这里for循环遍历从索引0开始遍历interceptorList集合中的所有拦截器，这个集合拦截器的索引顺序就是我们在配置文件中配置的顺序，因此preHandle()是按照配置顺序执行

postHandle

• 这里会调用所有拦截器的postHandle()方法：

  

  • 这个方法的调用是在applyPreHandler()这个方法执行完后执行的，因此如果这个applyPreHandler()方法在遍历所有拦截器的preHandle()方法时碰到了返回false的，即不放行，则会直接return掉，不会执行这个applyPostHandle()方法。因此只要有一个拦截器不放行，则所有拦截器的postHandle()都不执行，如下图：
  • 

• 如果所有的PreHandle()方法都放行，则会执行这个applyPostHandle()方法，从这里可以看到它是从interceptorList集合的最后一个索引开始向前遍历的，因此是反序

  • 

afterComplation

• 下面代码会执行所有拦截器的afterComplation()方法，可以看出for循环遍历拦截器集合的时候也是从后往前遍历的

  

上述的triggerAfterCompletion()方法有两个地方可能会执行：

• 1. 如果有拦截器不放行：在执行所有PreHandle()方法的applyPreHandler()方法中，如果碰到某个拦截器的PreHandle()方法不放行，就会执行triggerAfterCompletion()方法。此时不会渲染视图，因为被拦截了。

     

  2. 如果全部放行：则会在视图渲染之后执行，上面有分析。

• 有拦截器不放行时：

  • 源码：for循环里面的if语句在判断时就会执行preHandle()，如果不放行则进入if语句，里面会调用triggerAfterCompletion()方法

  • 此时preHandle()返回false的那个拦截器之前的拦截器的afterComplation()会执行，理由如下：

    • 这里会调用最后一个放行的拦截器和它之前的所有拦截器的afterComplation()方法：

      

    • this.interceptorIndex就是在applyPreHandler()方法中赋值的，它记录的是最后一个放行的拦截器在集合中的索引，而preHandle()方法在碰到返回false的preHandle()拦截器方法后就会执行这个triggerAfterCompletion()方法(即这个拦截器的preHandle()方法不放行)，此时this.interceptorIndex就记录的是最后一个放行的拦截器索引。

    • 因此返回false的拦截器之前的拦截器的afterComplation()都会执行

• 若某个拦截器的preHandle()返回了false

  • 即如果某个拦截器的preHandle()返回了false，则preHandle()执行次数会比afterComplation()执行次数多一次，多的就是按个返回false的preHandle()

过滤器和拦截器的区别和执行顺序

一、两者的区别

1、拦截器

java里的拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行，同时也提供了一种可以提取action中可重用部分的方式。在AOP（Aspect-Oriented Programming）中拦截器用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。------[百度百科]

2、过滤器

在Web中称之为Filter，通过配置多个过滤器，Web系统可以对所有的Servlet请求进行一层一层的过滤，以完成一些特殊的功能。例如常用的资源访问权限控制、特殊字符以及敏感词过滤、响应信息压缩等功能。

3、区别

1> 拦截器是基于java的反射机制的，而过滤器是基于函数回调。
2> 拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
3> 拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
4> 拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
5> 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。(注：这里的调用一次，是对于构造函数而言。而doFilter会对匹配的请求做持续的处理。)

6> 拦截器可以获取IOC容器中的各个bean，而过滤器就不行，所以我们可以在拦截器里注入一个service，可以调用业务逻辑。

二、两者的执行顺序

之后根据这张图，我们把过滤器和拦截器，摘出来，画出一张专一详解过滤器、拦截器，各函数执行顺序的示意图：

话不多说，都在图上了，请自行观摩。

三、过滤器代码demo

你在web.xml中分别配置firstTestFilter、secondTestFilter两个过滤器。

    <filter>
        <filter-name>firstTestFilter</filter-name>
        <filter-class>com.demo.Filter.FirstTestFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>firstTestFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 
    <filter>
        <filter-name>secondTestFilter</filter-name>
        <filter-class>com.demo.Filter.SecondTestFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>secondTestFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

分别创建FirstTestFilter、SecondTestFilter两个实现了Filter的过滤器类。

FirstTestFilter类：

package com.demo.Filter;
 
import javax.servlet.*;
import java.io.IOException;
 
/**
 * @author :xch
 * date:Create in 2018/7/16 13:48
 * description:
 */
public class FirstTestFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("我是第一个Filter,执行filterChain.doFilter(request,response)之前。");
        filterChain.doFilter(request,response);
        System.out.println("我是第一个Filter,执行filterChain.doFilter(request,response)之后。");
    }
 
    @Override
    public void destroy() {
 
    }
}

SecondTestFilter类：

package com.demo.Filter;
 
import javax.servlet.*;
import java.io.IOException;
 
/**
 * @author :xch
 * date:Create in 2018/7/16 13:48
 * description:
 */
public class SecondTestFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("我是第二个Filter,执行filterChain.doFilter(request,response)之前。");
        filterChain.doFilter(request,response);
        System.out.println("我是第二个Filter,执行filterChain.doFilter(request,response)之后。");
    }
 
    @Override
    public void destroy() {
 
    }
}

注：chain.doFilter将请求转发给过滤器链的下一个filter , 如果下面没有filter，那就是你请求的资源。

四、拦截器代码demo

在spring-mvc的配置文件中配置公共的拦截器：

<mvc:interceptors>
        <!-- 对所有请求都拦截，公共拦截器 -->
        <bean name="testInterceptor" class="com.demo.interceptor.TestInterceptor" />
</mvc:interceptors>

公共拦截器的实现类TestInterceptor：

package com.demo.interceptor;
 
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * @author :xch
 * date:Create in 2018/7/16 14:06
 * description:
 */
public class TestInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("我是测试的拦截器函数：preHandle");
        return true;
    }
 
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("我是测试的拦截器函数：postHandle");
    }
 
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("我是测试的拦截器函数：afterCompletion");
    }
}

代码部分结束，我们启动一下项目，随便发送一个请求，这个请求接口会打印信息：“我是TestController类函数：test”。

看一下控制台的打印信息：

打印顺序完全正确，也验证了图例的正确性。