SpringMVC請求流程原始碼分析

一、SpringMVC使用

1.工程建立

建立maven工程。
新增java、resources目錄。
引入Spring-webmvc 依賴。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.4</version>
</dependency>

刪除 src/main/webapp/WEB-INF/web.xml 組態檔。從tomcat的範例工程中找一份web.xml替換，這裡推薦從\webapps\ROOT\WEB-INF中拿，並且在其中新增context的監聽器和servlet設定，設定如下。

<!--Context 載入監聽器 -->
<listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
     <servlet-name>dispatcherServlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <init-param>
     	 <param-name>contextConfigLocation</param-name>
         <param-value>classpath:application.xml</param-value>
     </init-param>
     <!--Web伺服器一旦啟動，Servlet就會範例化建立物件，然後初始化(預備建立物件)-->
     <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

在 resources 目錄中建立springmvc.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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--設定spring包掃描路徑，被@Component、@Controller、@Service、@Repository標註的類都會交由Spring託管一個Bean-->
    <context:component-scan base-package="com.ybe.*"/>
    <!--設定檢視解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

在 src/main/webapp/WEB-INF/下新增 applicationContext.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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
</beans>

建立Controller類，程式碼如下：

package com.ybe.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String helloWorld(){
        System.out.println("hello world");
        return "index";
    }
}

2.工程設定

點選Add Configurations或者Run->Add Configurations。
設定本地tomcat的目錄
設定瀏覽器地址，點選上圖左上角的 + 號，選擇Tomcat Server選項後，點選 Deployment 選項，點選右邊的 + 號。
選擇Artifacts後，選擇springMvcTest:war。

3.啟動工程

二、SpringMVC啟動過程

SpringMVC是依賴Java的Web容器技術，整個springmvc的啟動過程是建立在Servlet技術基礎上的。SpringMVC藉助Web容器和Servelt的生命週期進行了擴充套件。父容器的初始化在 ContextLoaderListener 類中initWebApplicationContext方法進行，子容器的初始化在 DispatcherServlet 中init方法中進行。

1.父容器啟動過程

如果web.xml中設定了ContextLoaderListener監聽器，則web容器啟動的時候先會呼叫監聽器ContextLoaderListener的initWebApplicationContext方法。整個過程如下圖：

initWebApplicationContext中的整個過程就是建立了一個spring容器（父容器），並且根據springApplication.xml的設定內容往Spring容器中注入Bean物件。最後把spring容器（this.context物件）放入serveltContext 的屬性中。

2.子容器啟動過程（SpringMvc容器）

DispatcherServlet 是在web.xml組態檔中設定的Servlet類,是SpringMVC的請求分發核心類。所有的請求都由DispatcherServlet去分發處理。

DispatcherServlet 的繼承關係如下圖：

上圖可知DispatcherServlet 繼承了HttpServletBean。在HttpServletBean中重寫了init()，Web容器啟動的時候會根據組態檔中定義的Servlet進行建立，並且會根據設定項（load-on-startup）覺定在什麼時候呼叫Servlet的init方法，init方法在整個Servlet的生命週期中只會呼叫一次。初始化init方法的主體實現過程如下：

1.WebApplicationContextUtils.getWebApplicationContext(getServletContext()) 從ServletContext中獲取屬性為WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE的物件，即Spring父容器物件。

2.wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()))，給子容器新增應用監聽器，該監聽器在後面的finishRefresh()方法中進行觸發，方法裡面封裝了初始化SpringMVC中九大元件的邏輯。

3.publishEvent(new ContextRefreshedEvent(this))釋出Context重新整理事件，會觸發SourceFilteringListener監聽器，最終進行initStrategies的呼叫。

3.九大元件的初始化

initStrategies是SpringMVC中九大元件的初始化方法其中9個方法對應9個元件的初始化，本文中只講對映器和介面卡的建立過程，initStrategies程式碼如下：

// 初始化 MultipartResolver:主要用來處理檔案上傳.如果定義過當前型別的bean物件，那麼直接獲取，如果沒有的話，可以為null
initMultipartResolver(context);
// 初始化 LocaleResolver:主要用來處理國際化設定,基於URL引數的設定(AcceptHeaderLocaleResolver)，基於session的設定(SessionLocaleResolver)，基於cookie的設定(CookieLocaleResolver)
initLocaleResolver(context);
// 初始化 ThemeResolver:主要用來設定主題Theme
initThemeResolver(context);
// 初始化 HandlerMapping:對映器，用來將對應的request跟controller進行對應
initHandlerMappings(context);
// 初始化 HandlerAdapter:處理介面卡，主要包含Http請求處理器介面卡，簡單控制器處理器介面卡，註解方法處理器介面卡
initHandlerAdapters(context);
// 初始化 HandlerExceptionResolver:基於HandlerExceptionResolver介面的例外處理
initHandlerExceptionResolvers(context);
// 初始化 RequestToViewNameTranslator:當controller處理器方法沒有返回一個View物件或邏輯檢視名稱，並且在該方法中沒有直接往response的輸出流裡面寫資料的時候，spring將會採用約定好的方式提供一個邏輯檢視名稱
initRequestToViewNameTranslator(context);
// 初始化 ViewResolver: 將ModelAndView選擇合適的檢視進行渲染的處理器
initViewResolvers(context);
// 初始化 FlashMapManager: 提供請求儲存屬性，可供其他請求使用
initFlashMapManager(context);

1.處理器對映器的初始化

1.initHandlerMappings 初始化對映器，在此方法中第一步會獲取容器中實現了HandlerMapping的Bean物件，如果有則用自定義的HandlerMapping實現類作為this.handlerMappings的值；如果沒有自定義類，則獲取SpringMVC預先定義好的策略類。程式碼流程如下：

2.ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);獲取DispatcherServlet.properties資原始檔，位置在spring-webmvc中，路徑resources/org/springframework/web/servlet/DispatcherServlet.properties，該資原始檔中定義了SpringMVC元件的預設實現策略類，具體內容如下：

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,org.springframework.web.servlet.function.support.RouterFunctionMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,org.springframework.web.servlet.function.support.HandlerFunctionAdapter
    org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

由內容可知HandlerMapping 預製的策略類有 BeanNameUrlHandlerMapping、RequestMappingHandlerMapping、RouterFunctionMapping，其中 RequestMappingHandlerMapping 是我們常用的 HandlerMapping物件。

3.RequestMappingHandlerMapping 的初始化，因為RequestMappingHandlerMapping 實現了InitializingBean介面，所以在容器中初始化完之後會執行afterPropertiesSet方法，其中會呼叫super.afterPropertiesSet();父類別為AbstractHandlerMethodMapping。此方法中會呼叫initHandlerMethods()，程式碼如下：

protected void initHandlerMethods() {
    // 遍歷 Bean ，逐個處理
    for (String beanName : getCandidateBeanNames()) {
        // 排除目標代理類，AOP 相關，可檢視註釋
        if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
            // 處理 Bean
            processCandidateBean(beanName);
        }
    }
    // 初始化處理器的方法們，目前沒有特殊業務邏輯，只是列印紀錄檔
    handlerMethodsInitialized(getHandlerMethods());
}

4.processCandidateBean方法中會判斷BeanName的Bean是否有Controller.class或者RequestMapping.class註解來生成具體的HandlerMethod物件。

2.處理器介面卡的初始化

1.initHandlerAdapters 介面卡初始化,過程和對映器相似。從上面的內容可知HandlerAdapter與之的策略類有 HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、RequestMappingHandlerAdapter、HandlerFunctionAdapter。其中 RequestMappingHandlerAdapter 是我們常用的處理器介面卡。

2.RequestMappingHandlerAdapter實現了InitializingBean介面，在容器中初始化完之後會呼叫afterPropertiesSet方法，在此方法中會初始化引數解析器、繫結引數解析器、返回值解析器。此方法程式碼如下：

@Override
public void afterPropertiesSet() {
    // Do this first, it may add ResponseBody advice beans
    // 初始化註釋了@ControllerAdvice的類的相關屬性
    initControllerAdviceCache();

    // 初始化 argumentResolvers 屬性
    if (this.argumentResolvers == null) {
        List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
        this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    }
    // 初始化 initBinderArgumentResolvers 屬性
    if (this.initBinderArgumentResolvers == null) {
        List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
        this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    }
    // 初始化 returnValueHandlers 屬性
    if (this.returnValueHandlers == null) {
        List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
        this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
    }
}

4.攔截器的初始化

因為所有的HandlerMapping預製的策略類都繼承了AbstractHandlerMapping ，而AbstractHandlerMapping 實現了ApplicationContextAware介面，所以在具體的HandlerMapping策略類初始化完之後會呼叫initApplicationContext方法，該方法中具體實現了攔截器的建立，程式碼如下：

protected void initApplicationContext() throws BeansException {
    // 空實現，交給子類實現，用於註冊自定義的攔截器到interceptors中，目前暫無子類實現
    extendInterceptors(this.interceptors);
    // 掃描已註冊的MappedInterceptor的Bean們，新增到adaptedInterceptors中
    detectMappedInterceptors(this.adaptedInterceptors);
    // 將interceptors初始化成 HandlerInterceptor型別，新增到adaptedInterceptors中
    initInterceptors();
}

三、SpringMVC請求過程

1.請求流程圖

2.業務描述

1.請求進來後會呼叫FrameworkServlet的service()方法，該方法中會呼叫(HttpServlet) super.service 方法，其中會呼叫doXXX()方法，而doXXX()方法在FrameworkServlet重寫，每個doXXX()方法中又會呼叫processRequest(request, response)方法，processRequest中會呼叫doService()，doService()中又會呼叫doDispatch()，整個業務處理邏輯定義在doDispatch方法中。

2.迴圈遍歷在啟動過程中建立的handlerMapping處理器對映器集合查詢對應處理器，傳入引數為 request 請求物件，返回的是HandlerExecutionChain型別的物件，程式碼如下

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;
}

在getHandler方法中如果找到具體的handler物件(HandlerMethod型別)，會繼續封裝handler物件為一個executionChain處理器鏈鏈物件(HandlerExecutionChain型別)，程式碼如下：

Object handler = getHandlerInternal(request);
if (handler == null) {
	handler = getDefaultHandler();
}
// 如果handler為null 即返回null。說明當前的處理器對映器不匹配。
if (handler == null) {
	return null;
}
// Bean name or resolved handler?
if (handler instanceof String) {
    String handlerName = (String) handler;
    handler = obtainApplicationContext().getBean(handlerName);
}

// Ensure presence of cached lookupPath for interceptors and others
if (!ServletRequestPathUtils.hasCachedPath(request)) {
	initLookupPath(request);
}
//建立處理器鏈
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

getHandlerInternal是多型方法，具體的實現類中有不同的實現方式。查詢具體的HandlerMethod邏輯比較複雜，請自行檢視原始碼。

3.迴圈遍歷在啟動過程中建立的handlerAdapters處理器介面卡集合查詢對應處理器介面卡，傳入引數為handler處理器物件，返回的是RequestMappingHandlerAdapter型別的處理器介面卡，程式碼如下：

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        //迴圈判斷哪個介面卡能處理傳入的處理器
        for (HandlerAdapter adapter : this.handlerAdapters) {
            if (adapter.supports(handler)) {
                return adapter;
            }
        }
    }
    throw new ServletException("No adapter for handler [" + handler +
                               "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

4.迴圈執行mappedHandler(HandlerExecutionChain攔截器鏈)物件的攔截器preHandle方法。

5.處理器介面卡呼叫處理方法，最終會執行ServletInvocableHandlerMethod.invokeAndHandle()方法，此方法中會呼叫invokeForRequest，invokeForRequest中會先拿到Controller中方法的具體引數值，再執行該方法，最後會返回ModelAndView物件。

6.迴圈執行mappedHandler(HandlerExecutionChain攔截器鏈)物件的攔截器postHandle方法。

7.processDispatchResult方法中會先查詢找到具體的檢視引擎，程式碼如下：

protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
                               Locale locale, HttpServletRequest request) throws Exception {
    if (this.viewResolvers != null) {
        for (ViewResolver viewResolver : this.viewResolvers) {
            View view = viewResolver.resolveViewName(viewName, locale);
            if (view != null) {
                return view;
            }
        }
    }
    return null;
}

然後渲染檢視內容，底層其實就是請求的轉發，程式碼如下：

public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
                   HttpServletResponse response) throws Exception {
    if (logger.isDebugEnabled()) {
        logger.debug("View " + formatViewName() +
                     ", model " + (model != null ? model : Collections.emptyMap()) +
                     (this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
    }
    //合併返回結果，將 Model 中的靜態資料和請求中的動態資料進行合併
    Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
    prepareResponse(request, response);
    //進行渲染
    renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
}

8.迴圈執行mappedHandler(HandlerExecutionChain攔截器鏈)物件的攔截器afterCompletion方法。