拦截器原理多个拦截器执行顺序

1、根据当前请求，找到**HandlerExecutionChain【可以处理请求的handler以及handler的所有 拦截器】

2、先来顺序执行 所有拦截器的 preHandle方法

• 1、如果当前拦截器prehandler返回为true。则执行下一个拦截器的preHandle
• 2、如果当前拦截器返回为false。直接 倒序执行所有已经执行了的拦截器的 afterCompletion；

3、如果任何一个拦截器返回false。直接跳出不执行目标方法

4、所有拦截器都返回True。执行目标方法

5、倒序执行所有拦截器的postHandle方法。

6、前面的步骤有任何异常都会直接倒序触发 afterCompletion

7、页面成功渲染完成以后，也会倒序触发 afterCompletion

package com.example.jwt2021921.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @Auther: 叶川江
 * @Date: 2021/9/18 12:44
 * @Description: 拦截器，拦截所有资源
 */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //设置第一个拦截器
        registry.addInterceptor(authenticationInterceptor1())
                .addPathPatterns("/api/get")//拦截路径
        .excludePathPatterns("/api/login");//放行路径
        //设置第二个拦截器
        registry.addInterceptor(authenticationInterceptor2())
                .addPathPatterns("/api/get")//拦截路径
                .excludePathPatterns("/api/login");//放行路径

        /**
         * 拦截器的顺序根据你加入的顺序来的
         * authenticationInterceptor1，authenticationInterceptor2就是拦截器具体逻辑的内容的2个类，需要实现implements HandlerInterceptor
         * 拦截路径个过滤路径都是自己看业务定义
         */
    }


    @Bean
    public AuthenticationInterceptor authenticationInterceptor1() {
        return new AuthenticationInterceptor();
    }
    @Bean
    public AuthenticationInterceptor authenticationInterceptor2() {
        return new AuthenticationInterceptor();
    }
}

乾坤未定，你我皆是黑马，奥里给冲

为了对比多个拦截器的执行顺序，先创建两个拦截器打比方

第一个拦截器:

public class MyInterceptor implements HandlerInterceptor {
    /**
     * 目标方法执行之前执行
     *
     * @return true不拦截，如果为false，那么后面一连串方法都不会执行(Controller。postHandle。afterCompletion。。等等)
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandle1.....");
            return true;
    }

    /**
     * 在目标执行之后 视图返回之前执行
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle1.....");
    }

    /**
     * 在整个流程都执行完毕后执行,记录日志、异常等(用的不多)
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion1.....");
    }
}

第二个拦截器:

public class MyInterceptor2 implements HandlerInterceptor {
    /**
     * 目标方法执行之前执行
     *
     * @return true不拦截，如果为false，那么后面一连串方法都不会执行(Controller。postHandle。afterCompletion。。等等)
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle2.....");
        return true;
    }

    /**
     * 在目标执行之后 视图返回之前执行
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle2.....");
    }

    /**
     * 在整个流程都执行完毕后执行,记录日志、异常等(用的不多)
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion2.....");
    }
}

Spring MVC配置文件中配置拦截器:先配置拦截器1，再配置拦截器2

<!--    配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--            拦截路径,对哪些资源执行拦截操作  /**代表对所有都拦截-->
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <!--            拦截路径,对哪些资源执行拦截操作  /**代表对所有都拦截-->
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>
    <!--配置拦截器-->

启动Tomcat服务并访问相应资源，运行结果:

 调换SpringMVC配置文件拦截器的顺序:先配置拦截器2，再配置拦截器1

<!--    配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--            拦截路径,对哪些资源执行拦截操作  /**代表对所有都拦截-->
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <!--            拦截路径,对哪些资源执行拦截操作  /**代表对所有都拦截-->
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
    <!--配置拦截器-->

再次运行Tomcat服务执行结果:

preHandle2.....
preHandle1.....
postHandle1.....
postHandle2.....
afterCompletion1.....
afterCompletion2.....

多个拦截器执行preHandle的顺序与Spring MVC配置文件中的配置顺序有关,将配置文件还原到拦截器1~拦截器2

<!--    配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--            拦截路径,对哪些资源执行拦截操作  /**代表对所有都拦截-->
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <!--            拦截路径,对哪些资源执行拦截操作  /**代表对所有都拦截-->
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>
    <!--配置拦截器-->

当第一个拦截器的preHandle方法返回true时，才会继续向下调用下一个拦截器的preHandle

修改一下代码，将第一个拦截器的preHandle方法改成false，试着运行程序，看看拦截器2的preHandle是否执行:

public class MyInterceptor implements HandlerInterceptor {
    /**
     * 目标方法执行之前执行
     *
     * @return true不拦截，如果为false，那么后面一连串方法都不会执行(Controller。postHandle。afterCompletion。。等等)
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandle1.....");
            return false;
    }

    /**
     * 在目标执行之后 视图返回之前执行
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle1.....");
    }

    /**
     * 在整个流程都执行完毕后执行,记录日志、异常等(用的不多)
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion1.....");
    }
}

执行结果:

只有preHandle1被执行 ，说明拦截器1的preHandle返回false拦截器2压根就不会执行，甚至拦截器1的postHandle和afterCompletion也不会执行