前言

我用的是最原始的Spring MVC使用方式，基于XML文件配置。

项目结构

导入依赖：

spring-webmvc：https://mvnrepository.com/artifact/org.springframework/spring-webmvc
javax.servlet-api：https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api

web.xml：

<web-app>  <display-name>Archetype Created Web Application</display-name>  <!-- 配置DispatcherServlet -->  <servlet>    <servlet-name>dispatcherServlet</servlet-name>    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    <!-- 配置初始化参数 -->    <init-param>      <param-name>contextConfigLocation</param-name>      <param-value>spring-mvc.xml</param-value>    </init-param>  </servlet>      <servlet-mapping>    <servlet-name>dispatcherServlet</servlet-name>    <url-pattern>/</url-pattern>  </servlet-mapping></web-app>

spring-mvc.xml：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:mvc="http://www.springframework.org/schema/mvc"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans       http://www.springframework.org/schema/beans/spring-beans.xsd       http://www.springframework.org/schema/mvc      http://www.springframework.org/schema/mvc/spring-mvc.xsd      http://www.springframework.org/schema/context      http://www.springframework.org/schema/context/spring-context.xsd">  <!-- 告知Spring框架在创建核心容器时需要扫描的包 -->  <context:component-scan base-package="com.gzy.springmvctest"/>  <!-- 配置视图解析器 -->  <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">    <property name="prefix" value="/WEB-INF/pages/"/>    <property name="suffix" value=".jsp"/>  </bean>  <!-- 开启Spring MVC对注解的支持 -->  <mvc:annotation-driven/></beans>

webapp文件夹结构：

执行流程

Spring MVC是基于组件的方式来执行流程的。

源码分析

源码按Spring MVC的执行流程逐步分析（依照上面的流程图）。

第一步：

根据执行流程的步骤来，请求最先接触的是DispatcherServlet，它是整个Spring MVC的中央控制器。看名字可知它是一个Servlet，我这里没有指定<load-on-startup>参数，则默认是第一次访问时创建，所以当我第一次发送请求时才会创建DispatcherServlet。

既然DispatcherServlet是一个Servlet，我们来回顾一下Servlet的生命周期：

初始化：init方法。
处理请求：service方法。
销毁：destroy方法。

接下来看到DispatcherServlet的初始化init方法，它在间接父类HttpServletBean中，这个方法主要是进行一些最基础内容的初始化，并且提供了initServletBean方法供子类重写，FrameworkServlet类就对该方法进行了重写。

public final void init() throws ServletException {    // 设置DispatcherServlet的参数，就是<init-param>标签的内容    PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);    if (!pvs.isEmpty()) {        try {            BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);            ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());            bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));            initBeanWrapper(bw);            bw.setPropertyValues(pvs, true);        }        catch (BeansException ex) {            if (logger.isErrorEnabled()) {                logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);            }            throw ex;        }    }    // 子类重写    initServletBean();}

接着寻找DispatcherServlet的service方法，它在父类FrameworkServlet中。先是获取请求的HTTP方法，并将其解析为一个HttpMethod对，HttpMethod是Spring MVC对HTTP方法的再封装。随后判断请求是否为PATCH方法，我们这里是GET方法，故进入父类（HttpServlet类）的service方法。

// FrameworkServlet类protected void service(HttpServletRequest request, HttpServletResponse response)    throws ServletException, IOException {    // 获取请求的HTTP方法    HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());    if (httpMethod == HttpMethod.PATCH || httpMethod == null) {        processRequest(request, response);    }    else {        super.service(request, response);    }}

在HttpServlet类的service方法中，其实也很简单，就是根据不同的HTTP方法进行不同的处理，我们这里进入的是doGet方法。

protected void service(HttpServletRequest req, HttpServletResponse resp)    throws ServletException, IOException{    String method = req.getMethod();    if (method.equals(METHOD_GET)) {        long lastModified = getLastModified(req);        if (lastModified == -1) {            // servlet doesn't support if-modified-since, no reason            // to go through further expensive logic            doGet(req, resp);        } else {            long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);            if (ifModifiedSince < lastModified) {                // If the servlet mod time is later, call doGet()                // Round down to the nearest second for a proper compare                // A ifModifiedSince of -1 will always be less                maybeSetLastModified(resp, lastModified);                doGet(req, resp);            } else {                resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);            }        }    } else if (method.equals(METHOD_HEAD)) {        long lastModified = getLastModified(req);        maybeSetLastModified(resp, lastModified);        doHead(req, resp);    } else if (method.equals(METHOD_POST)) {        doPost(req, resp);    } else if (method.equals(METHOD_PUT)) {        doPut(req, resp);    } else if (method.equals(METHOD_DELETE)) {        doDelete(req, resp);    } else if (method.equals(METHOD_OPTIONS)) {        doOptions(req,resp);    } else if (method.equals(METHOD_TRACE)) {        doTrace(req,resp);    } else {        String errMsg = lStrings.getString("http.method_not_implemented");        Object[] errArgs = new Object[1];        errArgs[0] = method;        errMsg = MessageFormat.format(errMsg, errArgs);        resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);    }}

然后我们进入FramworkServlet类的doGet方法，里面没有什么逻辑，直接调用了另一个processRequest方法。而processRequest方法我们只需要关注它又调用了子类DispatcherServlet的doServlet方法。

// FrameworkServlet类protected final void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {processRequest(request, response);}protected final void processRequest(HttpServletRequest request, HttpServletResponse response)    throws ServletException, IOException {    // 省略其他内容...    try {        // 子类DispatcherServlet实现了该方法        doService(request, response);    }    catch (ServletException | IOException ex) {        failureCause = ex;        throw ex;    }    catch (Throwable ex) {        failureCause = ex;        throw new NestedServletException("Request processing failed", ex);    }    finally {        resetContextHolders(request, previousLocaleContext, previousAttributes);        if (requestAttributes != null) {            requestAttributes.requestCompleted();        }        logResult(request, response, failureCause, asyncManager);        publishRequestHandledEvent(request, response, startTime, failureCause);    }}

DispatcherServlet进到doService方法，这个方法也只需关注它调用了另一个doDispatch方法。

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {        // 省略其他内容...    try {        // 分派处理请求的组件        doDispatch(request, response);    }    finally {        if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {            // Restore the original attribute snapshot, in case of an include.            if (attributesSnapshot != null) {                restoreAttributesAfterInclude(request, attributesSnapshot);            }        }        if (requestPath != null) {            ServletRequestPathUtils.clearParsedRequestPath(request);        }    }}

doDispatch是DispatcherServlet中最重要的方法，这个方法的主要作用是分派处理请求的组件。

// DispatcherServlet类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);            // 决定使用哪个Handler来处理当前请求            mappedHandler = getHandler(processedRequest);            if (mappedHandler == null) {                noHandlerFound(processedRequest, response);                return;            }            // 决定使用哪个处理映射器            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());            // 获取当前请求的HTTP方法            String method = request.getMethod();            // 如果是GET或HEAD请求，就需要判断资源缓存是否过期            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;                }            }            // 执行过前置拦截器            if (!mappedHandler.applyPreHandle(processedRequest, response)) {                return;            }            // 通过HandlerAdapter执行Handler            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());            if (asyncManager.isConcurrentHandlingStarted()) {                return;            }                        applyDefaultViewName(processedRequest, mv);            // 执行后置拦截器            mappedHandler.applyPostHandle(processedRequest, response, mv);        }        catch (Exception ex) {            dispatchException = ex;        }        catch (Throwable err) {            dispatchException = new NestedServletException("Handler dispatch failed", err);        }        // 视图解析器解析视图        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);            }        }    }}

我们先看到checkMultipart方法，它是用于检查是否需要将当前请求解析为多部分类型请求。先进行一个判断，如果multipartResolver（多部分请求解析器）不存在或者判断当前请求不是多部分类型的请求，就直接退出方法。反之则使用multipartResolver（多部分请求解析器）来解析该请求。

// DispatcherServlet类// 检查是否需要将当前请求解析为多部分类型请求protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {    // 先判断是否有多部分类型解析器，只有当存在时才会解析当前请求    if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {        if (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null) {            if (request.getDispatcherType().equals(DispatcherType.REQUEST)) {                logger.trace("Request already resolved to MultipartHttpServletRequest, e.g. by MultipartFilter");            }        }        // 省略其他内容...    }    return request;}

第二步：

然后走到getHandler方法，第二步就是从该方法开始的。DispatcherServlet类中维护了一个名为handlerMappings的List集合，里面保存了两个默认的HandlerMapping（处理器映射器）：一个是RequestMappingHandlerMapping，另个一个是BeanNameUrlHandlerMapping。

RequestMappingHandlerMapping：用来处理通过注解来映射请求的Controller，例如@Controller、@RequestMapping等。

BeanNameUrlHandlerMapping：用来处理通过设置控制器Bean的name为请求URL路径的Controller。

getHandler方法会依次遍历每个HandlerMapping接口，直到某个HandlerMapping能获取到HandlerExecutionChain。因为我是使用注解配置的Controller，所以会使用RequestMappingHandlerMapping实现类。

// DispatcherServlet类protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {    if (this.handlerMappings != null) {        for (HandlerMapping mapping : this.handlerMappings) {            HandlerExecutionChain handler = mapping.getHandler(request);            if (handler != null) {                return handler;            }        }    }    return null;}

这里会有点绕！先进到RequestMappingHandlerMapping类间接抽象父类AbstractHandlerMapping的getHandler方法。然后会进入第一行代码的getHandlerInternal方法，这个方法在RequestMappingHandlerMapping类中，但是这方法又去到了父类AbstractHandlerMethodMapping的getHandlerInternal方法中。

HandlerMapping结构入下图所示：

// AbstractHandlerMapping类public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {    Object handler = getHandlerInternal(request);    if (handler == null) {        handler = getDefaultHandler();    }    if (handler == null) {        return null;    }        // 省略其他内容...    return executionChain;}

// RequestMappingHandlerMapping类protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {    request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);    try {        return super.getHandlerInternal(request);    }    finally {        ProducesRequestCondition.clearMediaTypesAttribute(request);    }}

先获取到请求的URL路径，然后通过lookupHandlerMethod方法来寻找Handler方法。

// AbstractHandlerMethodMapping类protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {    // 获取请求URL路径（这里是/hello）    String lookupPath = initLookupPath(request);        this.mappingRegistry.acquireReadLock();    try {        // 根据请求的URL路径寻找Handler中对应的映射方法        HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);        return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);    }    finally {        this.mappingRegistry.releaseReadLock();    }}

暂停一下！这里需要先讲解一下mappingRegistry对象。

先介绍几个跟Handler方法有关的类：

MappingRegistry：表示映射注册中心。里面保存了所有注册的映射（MappingRegistration）。
MappingRegistration：表示一个映射。里面存有请求映射信息（RequestMappingInfo）以及映射方法（HandlerMethod）。
HandlerMethod：表示Handler的一个映射方法。对Handler方法的封装，存有Handler方法的Method对象（用于反射）、方法参数、所在类的Class对象、所在类等信息。
RequestMappingInfo：存有映射方法的映射信息，其实就是存储的@RequestMapping注解的属性。

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {    // Bean init前调用    public void afterPropertiesSet() {        initHandlerMethods();    }        // 初始化所有Handler方法    protected void initHandlerMethods() {        // 获取所有候选Bean然后依次判断是否是Handler Bean        for (String beanName : getCandidateBeanNames()) {            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {                processCandidateBean(beanName);            }        }                // 真正处理Handler方法的初始化        handlerMethodsInitialized(getHandlerMethods());    }        // 获取所有候选Bean名称（其实就是IOC容器中所有的Bean的名称）    protected String[] getCandidateBeanNames() {        // detectHandlerMethodsInAncestorContexts参数默认为false        return (this.detectHandlerMethodsInAncestorContexts ?                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :                // 从IOC容器中获取所有Bean（不管是否是Handler Bean）的名称，因为是根据Object类型的Bean                obtainApplicationContext().getBeanNamesForType(Object.class));    }        // 判断该Bean是否是Handler Bean    protected void processCandidateBean(String beanName) {        Class<?> beanType = null;        try {            // 通过Bean名称获取到对应Class对象            beanType = obtainApplicationContext().getType(beanName);        }        catch (Throwable ex) {            // An unresolvable bean type, probably from a lazy bean - let's ignore it.            if (logger.isTraceEnabled()) {                logger.trace("Could not resolve type for bean '" + beanName + "'", ex);            }        }                // isHandler方法作用就是判断是否为Handler        if (beanType != null && isHandler(beanType)) {            // 检测Handler中的方法是否为映射方法            detectHandlerMethods(beanName);        }    }        // 省略其他内容...    }

isHandler方法主要作用是判断某个类是否是Handler（处理器），判断方法很简单，就是判断该类上是否标有@Controller或@RequestMapping注解。

// RequestMappingHandlerMapping类protected boolean isHandler(Class<?> beanType) {    return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||            AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));}

detectHandlerMethods方法用来检测该指定Handler中的方法有哪些是映射方法，并将映射方法注册到一个名为mappingRegistry的Map集合中，其中Key为RequestMappingInfo，Value为MappingRegistration。

protected void detectHandlerMethods(Object handler) {    // 获取Handler的Class对象    Class<?> handlerType = (handler instanceof String ?                            obtainApplicationContext().getType((String) handler) : handler.getClass());    if (handlerType != null) {        Class<?> userType = ClassUtils.getUserClass(handlerType);        // 筛选映射方法并存入Map集合中        Map<Method, T> methods = MethodIntrospector.selectMethods(userType,(MethodIntrospector.MetadataLookup<T>) method -> {try {return getMappingForMethod(method, userType);}catch (Throwable ex) {throw new IllegalStateException("Invalid mapping on handler class [" +userType.getName() + "]: " + method, ex);}});        if (logger.isTraceEnabled()) {            logger.trace(formatMappings(userType, methods));        }                // 将所有的映射方法处理后存入另一个Map集合中        methods.forEach((method, mapping) -> {            Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);            // 注册进mappingRegistry集合中            registerHandlerMethod(handler, invocableMethod, mapping);        });    }}// 注册Handler的映射方法protected void registerHandlerMethod(Object handler, Method method, T mapping) {    this.mappingRegistry.register(mapping, handler, method);}

// AbstractHandlerMethodMapping内部类MappingRegistry类public void register(T mapping, Object handler, Method method) {    this.readWriteLock.writeLock().lock();    try {        HandlerMethod handlerMethod = createHandlerMethod(handler, method);        validateMethodMapping(handlerMethod, mapping);        // 省略其他内容...        // 将一个映射存入映射注册中心        this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directPaths, name));    }    finally {        this.readWriteLock.writeLock().unlock();    }}

回到上面的lookupHandlerMethod方法，这里主要是通过请求的URL寻找对应的Handler映射方法。

Match：一个包装类，里面存有与请求匹配的RequestMappingInfo和对应的HandlerMethod。

// AbstractHandlerMethodMapping类protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {    // 存有与请求匹配的所有Match对象的集合    List<Match> matches = new ArrayList<>();    // 根据当前请求的URL获取所有对应的RequestMappingInfo对象的集合    List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);    // 在RequestMappingInfo对象的集合中再筛选出符合请求参数条件的，然后封装成Match添加至matches集合中    if (directPathMatches != null) {        addMatchingMappings(directPathMatches, matches, request);    }    if (matches.isEmpty()) {        addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);    }    if (!matches.isEmpty()) {        // 使用第一个匹配的Match对象        Match bestMatch = matches.get(0);        // 处理多个Match的情况        if (matches.size() > 1) {            Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));            matches.sort(comparator);            bestMatch = matches.get(0);            if (logger.isTraceEnabled()) {                logger.trace(matches.size() + " matching mappings: " + matches);            }            if (CorsUtils.isPreFlightRequest(request)) {                return PREFLIGHT_AMBIGUOUS_MATCH;            }            Match secondBestMatch = matches.get(1);            if (comparator.compare(bestMatch, secondBestMatch) == 0) {                Method m1 = bestMatch.handlerMethod.getMethod();                Method m2 = secondBestMatch.handlerMethod.getMethod();                String uri = request.getRequestURI();                throw new IllegalStateException(                    "Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");            }        }        request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);        handleMatch(bestMatch.mapping, lookupPath, request);        return bestMatch.handlerMethod;    }    else {        return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);    }}private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {    // 遍历当前请求URL所对应的所有HandlerMapping    for (T mapping : mappings) {        // 判断该HandlerMapping是否与当前请求所有参数都匹配，因为并不是通过URL获取的HandlerMapping都是符合要求的，请求还有其他的限制条件        T match = getMatchingMapping(mapping, request);        // 将匹配的HandlerMapping与对应的HandlerMethod封装成一个Match对象，然后添加至matches集合中        if (match != null) {            matches.add(new Match(match,                                  this.mappingRegistry.getRegistrations().get(mapping).getHandlerMethod()));        }    }}

第三步：

随后我们再次回到之前的getHandler方法中，通过getHandlerExecutionChain方法获取了一个包含Handler方法以及多个HandlerInterceptor（处理器拦截器）的HandlerExecutionChain（处理器执行链）。这里面涉及到一个类叫MappedInterceptor，这是映射拦截器，它带有路径模式匹配的HandlerInterceptor，也提供了匹配逻辑来测试拦截器是否适用于一个给定的请求路径。MappedInterceptor类被final关键字修饰，无法被继承，因此大多数的拦截器是否都是存在它内部，比如默认情况下Spring MVC会提供一个ConversionServiceExposingInterceptor（类型转换拦截器）并存入一个MappedInterceptor中，而所有的拦截器又会存储在AbstractHandlerMapping类的adaptedInterceptors集合中。

// AbstractHandlerMapping类public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {    Object handler = getHandlerInternal(request);        // 省略其他内容...    HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);    // 日志打印    if (logger.isTraceEnabled()) {        logger.trace("Mapped to " + handler);    }    else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {        logger.debug("Mapped to " + executionChain.getHandler());    }    // 判断是否要处理跨域问题    if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {        CorsConfiguration config = getCorsConfiguration(handler, request);        if (getCorsConfigurationSource() != null) {            CorsConfiguration globalConfig = getCorsConfigurationSource().getCorsConfiguration(request);            config = (globalConfig != null ? globalConfig.combine(config) : config);        }        if (config != null) {            config.validateAllowCredentials();        }        executionChain = getCorsHandlerExecutionChain(request, executionChain, config);    }    return executionChain;}// 获取处理器执行链protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {    // 初始化处理器执行链    HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?                                   (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));    // 遍历adaptedInterceptors集合中的拦截器，依次添加进HandlerExecutionChain的interceptorList集合中    for (HandlerInterceptor interceptor : this.adaptedInterceptors) {        if (interceptor instanceof MappedInterceptor) {            MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;            if (mappedInterceptor.matches(request)) {                chain.addInterceptor(mappedInterceptor.getInterceptor());            }        }        else {            chain.addInterceptor(interceptor);        }    }    return chain;}

谈谈这个HandlerExecutionChain，该类里面存储了Handler方法以及装有对应拦截器的List集合，还有前置处理方法、后置处理方法和完成触发方法。

public class HandlerExecutionChain {    private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);    // Handler方法    private final Object handler;    // 拦截器    private final List<HandlerInterceptor> interceptorList = new ArrayList<>();    private int interceptorIndex = -1;        // 省略其他内容...        boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {        for (int i = 0; i < this.interceptorList.size(); i++) {            HandlerInterceptor interceptor = this.interceptorList.get(i);            if (!interceptor.preHandle(request, response, this.handler)) {                triggerAfterCompletion(request, response, null);                return false;            }            this.interceptorIndex = i;        }        return true;    }        void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)        throws Exception {        for (int i = this.interceptorList.size() - 1; i >= 0; i--) {            HandlerInterceptor interceptor = this.interceptorList.get(i);            interceptor.postHandle(request, response, this.handler, mv);        }    }    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {        for (int i = this.interceptorIndex; i >= 0; i--) {            HandlerInterceptor interceptor = this.interceptorList.get(i);            try {                interceptor.afterCompletion(request, response, this.handler, ex);            }            catch (Throwable ex2) {                logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);            }        }    }}

Spring MVC详细源码解析（上篇）

前言

项目结构

相关组件

DispatcherServlet（前端控制器）

HandlerMapping（处理器映射器）

HandlerAdapter（处理器适配器）

Handler（处理器）

ViewResolver（视图解析器）

View（视图）

执行流程

源码分析

Spring MVC详细源码解析（上篇）

前言

项目结构

相关组件

DispatcherServlet（前端控制器）

HandlerMapping（处理器映射器）

HandlerAdapter（处理器适配器）

Handler（处理器）

ViewResolver（视图解析器）

View（视图）

执行流程

源码分析

相关推荐