SpringBoot拦截器的使用及其原理——源码学习

该文的SpringBoot版本：2.3.4
SpringBoot在web场景下，底层使用的是SpringMVC，所以这篇文章讲的本质上还是SpringMVC的内容。

1、拦截其的使用

使用拦截器有三步：

1. 实现HandlerInterceptor接口下的三个方法，分别是preHandle，postHandle，afterCompletion
2. 在WebMvcConfigurer中注册
3. 配置拦截路径和放行路径

1.1实现HandlerInterceptor接口

public class myInterceptor  implements HandlerInterceptor {
	//目标方法执行前，其中boolean返回值代表的就是拦截的结果
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return false;
    }
	//目标方法执行后
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }
	//视图渲染或出现异常后
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

1.2、1.3 注册拦截器和拦截配置

@Configuration
public class MyConfig implements WebMvcConfigurer{
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new myInterceptor())
                .addPathPatterns("/**") //拦截所有的请求，注意这里也会把静态资源拦截
                .excludePathPatterns("/index", "/static"); // 排除首页和静态资源
    }
}

2、拦截器原理

来到服务器的请求都会交由DispatchServlet的doDispatch()方法处理，这其中就包括了拦截器的执行。

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// 获得当前请求的处理器，以及拦截器
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				//执行拦截器的preHandle
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
				//执行拦截器的postHandle
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			//处理分发结果，中间先会处理视图，完成渲染后执行拦截器的afterCompletion
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		//以上发生任何的错误，都会触发执行拦截器的afterCompletion
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

源码中已经讲拦截器三个方法的执行展示的非常清楚，preHandle在执行handler（controller.method()）前，postHandle在执行handler后渲染视图前，afterCompletion在渲染视图后，而且在执行preHandle、handler、postHandle过程中一旦出现错误，都会触发afterCompletion的执行。

以上是一个触发器的情况，如果存在多个触发器呢？执行的顺序又是怎么的？

mappedHandler = getHandler(processedRequest);

获取请求的handler时，返回的是HandlerExecutionChain的对象，handler和interceptor被封装在这个类中，interceptor的执行也是交由这个类来管理

需要留意的是该类中有一个变量private int interceptorIndex = -1;，它记录了执行的interceptor的index，执行顺序与其密切相关。

对于preHandle

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			//顺序执行interceptor的preHandle
			for (int i = 0; i < interceptors.length; i++) {
				HandlerInterceptor interceptor = interceptors[i];
				if (!interceptor.preHandle(request, response, this.handler)) {
					//preHandle返回fasle(被拦截)，则会触发afterCompletion执行
					triggerAfterCompletion(request, response, null);
					return false;
				}
				//在类中维护了一个拦截器的index
				this.interceptorIndex = i;
			}
		}
		return true;
	}

对于postHandle

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

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			//逆序执行
			//根据doDispacth()中的try catch代码，这里一旦报错，也会触发afterCompletion的执行
			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顺序执行，postHandle逆序执行，afterCompletion逆序执行。
• 如果某个拦截器的preHandle方法拦截或报错，则所有拦截器的postHandle都不会执行，执行过preHandle方法的拦截器的afterCompletion方法会逆序执行。
• 如果某个拦截器的postHandle方法报错，则后续拦截器的postHandle方法不再执行，但所有拦截器的afterCompletion方法都会逆序执行。