搭建好Spring MVC环境以后，我们创建一个拦截器：
名为MyInterceptor并实现HandlerInterceptor接口：
实现接口方法、便于观察我们只在控制台输出对应的方法名：
package com.jd.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class MyInterceptor implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("preHandle");
return true;
//初始实现方法代码中，此处返回的是false
//改为true的原因在下面分析时机时会详细说明
}
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("postHandle");
}
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("afterCompletion");
}
}
拦截器创建好以后，我们在spring xml文件中进行启用设置：
<mvc:interceptors >
<mvc:interceptor>
<!-- path属性用于限制能够匹配的请求 -->
<mvc:mapping path="/userinfo/*"/>
<bean class="com.jd.interceptor.MyInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
controller方法：
主页面请求链接:
目标页面：
发送请求：
收到请求后DispatcherServlet类对象如下：
执行FrameworkServlet类service方法、
执行HttpServlet类service方法、
执行FrameworkServlet类doGet方法、
执行FrameworkServlet类processRequest方法、
执行DispatcherServlet类doService方法、
（详情参见Spring MVC请求执行过程）
执行DispatcherServlet类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)
根据request得到一个HandlerExecutionChain对象
包含了mvc模块的拦截器即handlerInterceptor和真正处理请求的handler*/
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null || mappedHandler.getHandler() == null) {
noHandlerFound(processedRequest, response);
return;
}
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (logger.isDebugEnabled()) {
logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
}
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
/*1、调用applyPreHandle方法，可见此if分支在下面语句之前
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
所以此方法是在执行controller方法前执行*/
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
/*经过applyPreHandle方法（和拦截器preHandle方法）后
执行handle方法，完成controller方法
（这一行执行完我们会看到控制台输出controller）*/
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
applyDefaultViewName(processedRequest, mv);
/*2、完成controller方法后，调用applyPostHandle方法，可见此方法在语句
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
前执行*/
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
/*执行完applyPostHandle方法（和拦截器postHandle方法）后
调用processDispatchResult方法*/
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
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()) {
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}
/*跳转自doDispatch方法
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
---------------------------------------*/
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
boolean errorView = false;
if (exception != null) {
if (exception instanceof ModelAndViewDefiningException) {
logger.debug("ModelAndViewDefiningException encountered", exception);
mv = ((ModelAndViewDefiningException) exception).getModelAndView();
}
else {
Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
mv = processHandlerException(request, response, handler, exception);
errorView = (mv != null);
}
}
if (mv != null && !mv.wasCleared()) {
/*执行render方法，可见render方法是在执行完
applyPostHandle方法（和拦截器postHandle方法）后执行。
这一步执行完，响应的视图将处理完毕*/
render(mv, request, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
"': assuming HandlerAdapter completed request handling");
}
}
if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
return;
}
if (mappedHandler != null) {
/*3、在render方法执行完后，执行triggerAfterCompletion方法*/
mappedHandler.triggerAfterCompletion(request, response, null);
}
}
1、执行HandlerExecutionChain类中的applyPreHandle方法
/*跳转自doDispatch方法
if(!mappedHandler.applyPreHandle(processedRequest, response))
--------------------------------------------------*/
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
//获取拦截器
HandlerInterceptor[] interceptors = getInterceptors();
//判断拦截器是否为空
if (!ObjectUtils.isEmpty(interceptors)) {
//遍历拦截器
for (int i = 0; i < interceptors.length; i++) {
//获取到我们的MyInterceptor拦截器
HandlerInterceptor interceptor = interceptors[i];
/*此时interceptor即为MyInterceptor类上转型对象
调用preHandle时出现多态现象
执行我们MyInterceptor类中的preHandle方法，并返回一个布尔类型结果
（这一行执行完我们就会看到控制台输出preHandle）*/
if (!interceptor.preHandle(request, response, this.handler)) {
triggerAfterCompletion(request, response, null);
return false;
}
this.interceptorIndex = i;
}
}
return true;
}
可见：
if(!interceptor.preHandle(request, response, this.handler))为true，则进入if分支最后返回false，则doDispatch方法中if(!mappedHandler.applyPreHandle(processedRequest, response))判断为true进入if分支将直接结束doDispatch方法。2、执行HandlerExecutionChain类中的applyPostHandle方法
/*跳转自doDispatch方法
mappedHandler.applyPostHandle(processedRequest, response, mv);
--------------------------------------------------*/
void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
//获取拦截器
HandlerInterceptor[] interceptors = getInterceptors();
//判断拦截器是否为空
if (!ObjectUtils.isEmpty(interceptors)) {
for (int i = interceptors.length - 1; i >= 0; i--) {
//获取到我们的MyInterceptor拦截器
HandlerInterceptor interceptor = interceptors[i];
/*此时interceptor即为MyInterceptor类上转型对象
调用postHandle时出现多态现象
执行我们MyInterceptor类中的postHandle方法
（这一行执行完我们就会看到控制台输出postHandle）*/
interceptor.postHandle(request, response, this.handler, mv);
}
}
}
可见：
3、执行HandlerExecutionChain类中的triggerAfterCompletion方法
/*跳转自processDispatchResult方法
mappedHandler.triggerAfterCompletion(request, response, null);
--------------------------------------------------*/
void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)
throws Exception {
//获取拦截器
HandlerInterceptor[] interceptors = getInterceptors();
//判断拦截器是否为空
if (!ObjectUtils.isEmpty(interceptors)) {
for (int i = this.interceptorIndex; i >= 0; i--) {
//获取到我们的MyInterceptor拦截器
HandlerInterceptor interceptor = interceptors[i];
try {
/*此时interceptor即为MyInterceptor类上转型对象
调用afterCompletion时出现多态现象
执行我们afterCompletion类中的afterCompletion方法
（这一行执行完我们就会看到控制台输出afterCompletion）*/
interceptor.afterCompletion(request, response, this.handler, ex);
}
catch (Throwable ex2) {
logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
}
}
}
}
可见：
至此，拦截器方法执行完毕
响应页面
控制台输出：
输出顺序即为对应方法执行顺序