SpringMVC拦截器执行顺序原理解释

建议阅读我的上一篇博客
SpringMVC拦截器详解

1. 两个拦截器的preHandle()方法都返回true

两个拦截器测试

package fei.springmvc.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * @author xiaoshijiu
 * @location SpringMVC/fei.springmvc.interceptor
 * @date 2019/3/4
 */
public class FristInterception implements HandlerInterceptor {
    //处理器方法映射之前执行
    //返回true，放行；false，不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("处理器方法映射之前执行1");
        return true;
    }

    //处理器方法映射执行之后会自动调用
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("处理器方法映射执行之后会自动调用1");
    }

    //所有请求完成之后调用
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("所有请求完成之后调用1");
    }
}

package fei.springmvc.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * @author xiaoshijiu
 * @location SpringMVC/fei.springmvc.interceptor
 * @date 2019/3/4
 */
public class SecondInterception implements HandlerInterceptor {
    //处理器方法映射之前执行
    //返回true，放行；false，不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("处理器方法映射之前执行2");
        return true;
    }

    //处理器方法映射执行之后会自动调用
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("处理器方法映射执行之后会自动调用2");
    }

    //所有请求完成之后调用
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("所有请求完成之后调用2");
    }
}

xml中配置

<mvc:interceptors>
	   <!--自定义拦截器(拦截所有请求)-->
       <bean class="fei.springmvc.interceptor.FristInterception"></bean>
       <!--自定义拦截器(拦截所有请求)-->
       <bean class="fei.springmvc.interceptor.SecondInterception"></bean>
</mvc:interceptors>

测试结果

可以看到preHandle()方法是按顺序执行，postHandle()和afterCompletion()方法是倒序执行
（这里的顺序是指在xml配置文件里面拦截器配置的先后顺序）

原因解释

打开org.springframework.web.servlet.HandlerExecutionChain.java文件查看源码

preHandle()源码

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = 0; i < interceptors.length; i++) {
				HandlerInterceptor interceptor = interceptors[i];
				if (!interceptor.preHandle(request, response, this.handler)) {
					triggerAfterCompletion(request, response, null);
					return false;
				}
				this.interceptorIndex = i;
			}
		}
		return true;
	}

postHandle()源码

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = interceptors.length - 1; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				interceptor.postHandle(request, response, this.handler, mv);
			}
		}
	}

afterCompletion()源码

void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = this.interceptorIndex; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				try {
					interceptor.afterCompletion(request, response, this.handler, ex);
				}
				catch (Throwable ex2) {
					logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
				}
			}
		}
	}

可以看到preHandle()方法遍历HandlerInterceptor[]数组的时候，i++（正方向）
而后两个方法遍历HandlerInterceptor[]数组的时候，都是i–（反过来了）
所以就显而易见了吧！！！

2. 第一个拦截器的preHandle()方法返回true，第二个返回false

测试结果

可以看到两个拦截器的preHandle()方法按顺序执行了，另外还有第一个拦截器的afterCompletion()方法执行了

原因解释
这里第一个拦截器的afterCompletion()方法执行了的原因也很好解释，对照preHandle()的源码

if (!interceptor.preHandle(request, response, this.handler)) {
		triggerAfterCompletion(request, response, null);
		return false;
}

如果preHandle()方法返回false，就会执行triggerAfterCompletion()方法。然后再看triggerAfterCompletion()方法源码，这时候遍历HandlerInterceptor[]数组的角标i只是上一个拦截器的角标（这次及后面的都不会遍历），所以这里只会执行第一个拦截器的afterCompletion()方法。

3. 第一个拦截器的preHandle()方法返回false，第二个返回true

测试结果

可以看到只调用了第一个拦截器的preHandle()方法

相信前面都弄懂的同学，这一个就显得更简单了吧，根据前面的思路并对照源码，很容易得出答案。

以上就是我个人对SpringMVC拦截器执行顺序的解释，欢迎联系指正~~