SpringMVC到底是如何處理請求的？

很多人會用 SpringMVC，但對它的處理請求的方式並不清楚，當我們學習一個知識的時候，瞭解它會讓我們更好地使用它，下面我們來看看 SpringMVC 是如何處理請求的。

請求流程的方式

先上圖：

Spring MVC 框架也是一個基於請求驅動的 Web 框架，並且使用了前端控制器模式（是用來提供一個集中的請求處理機制，所有的請求都將由一個單一的處理程序處理來進行設計，再根據請求映射規則分發給相應的頁面控制器（動作/處理器）進行處理。首先讓我們整體看一下 Spring MVC 處理請求的流程：

首先用戶發送請求，請求被 SpringMVC前端控制器（DispatherServlet）捕獲；
前端控制器（DispatherServlet）對請求 URL 解析獲取請求 URI，根據 URI，調用 HandlerMapping；
前端控制器（DispatherServlet）獲得返回的 HandlerExecutionChain（包括 Handler 對象以及 Handler 對象對應的攔截器）；
DispatcherServlet 根據獲得的 HandlerExecutionChain，選擇一個合適的 HandlerAdapter。（附註：如果成功獲得 HandlerAdapter 後，此時將開始執行攔截器的 preHandler(...) 方法）；
HandlerAdapter 根據請求的 Handler 適配並執行對應的 Handler；HandlerAdapter 提取 Request 中的模型數據，填充 Handler 入參，開始執行 Handler（Controller）。在填充 Handler 的入參過程中，根據配置，Spring 將做一些額外的工作：

HttpMessageConveter：將請求消息（如 Json、xml 等數據）轉換成一個對象，將對象轉換爲指定的響應信息；

數據轉換：對請求消息進行數據轉換。如 String 轉換成 Integer、Double 等；

數據格式化：如將字符串轉換成格式化數字或格式化日期等；

數據驗證：驗證數據的有效性（長度、格式等），驗證結果存儲到 BindingResult 或 Error 中）；
Handler 執行完畢，返回一個 ModelAndView （即模型和視圖）給 HandlerAdaptor；
HandlerAdaptor 適配器將執行結果 ModelAndView 返回給前端控制器；
前端控制器接收到 ModelAndView 後，請求對應的視圖解析器；
視圖解析器解析 ModelAndView 後返回對應 View；
渲染視圖並返回渲染後的視圖給前端控制器；
最終前端控制器將渲染後的頁面響應給用戶或客戶端。

案例實操

SpringMVC 請求執行源碼解讀

對於 SpringMVC 項目所有的請求入口（靜態資源除外）這裏都是從 web.xml 文件配置的前端控制器 DispatcherServlet 開始：

<!-- servlet請求分發器 -->
<servlet>
  <servlet-name>springMvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:servlet-context.xml</param-value>
  </init-param>
  <!-- 表示啓動容器時初始化該Servlet -->
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>springMvc</servlet-name>
  <!-- 這是攔截請求, /代表攔截所有請求,攔截所有.do請求 -->
  <url-pattern>/</url-pattern>
</servlet-mapping>

DispatcherServlet UML繼承關係圖如下：

這裏關注藍線部分繼承結構：DispatcherServlet-->FrameworkServlet-->HttpServletBean-->HttpServlet-->GenericServlet-->Servlet，對於請求核心時序圖如下：

對於 web 請求的處理，大家都知道是通過繼承 HttpServlet 重寫其 service 方法，這裏打開 DispatcherServlet 源碼發現這裏並沒有看到我們要找的 service 方法，此時到父類 FrameworkServlet 查找如下：可以看到父類重寫 HttpServlet service 方法。

FrameworkServlet#service

/**
 * Override the parent class implementation in order to intercept PATCH requests.
 */
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
   HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
   if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
      proce***equest(request, response);
   }
   else {
      super.service(request, response);
   }
}

從源碼分析來看當請求方法爲 patch 請求或者爲 null 時執行 proce***equest0 方法，其他情況則調用父類 service 方法，大家都知道 SpringMVC 請求大多請求是 get|post 請求爲主，此時繼續向上查看 FrameworkServlet 父類 HttpServletBean（抽象類繼承 HttpServlet 並未重寫 service 方法，所以向上繼續尋找)--> HttpServlet service 方法：

HttpServlet#service

    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException
    {
        HttpServletRequest  request;
        HttpServletResponse response;

        if (!(req instanceof HttpServletRequest &&
                res instanceof HttpServletResponse)) {
            throw new ServletException("non-HTTP request or response");
        }

        request = (HttpServletRequest) req;
        response = (HttpServletResponse) res;

        service(request, response);
    }
}

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 {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

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

可以看到 HttpServlet service 進行了重載，根據不同的請求類型然後調用不同處理方法，這裏以 get 請求爲例，當請求方法爲 get 請求時在重載 service 方法中調用 doGet 方法進行處理，這裏需要特別注意的是：HttpServlet 存在 doGet 方法實現，然而在繼承的子類中也存在 doGet 方法實現，到底調用哪個方法？很明顯調用子類的 doGet 方法（面向對象多態思想！！！）從繼承 UML 關係圖上看，最外層子類實現 doGet 方法的爲 FrameworkServlet ：

FrameworkServlet#doGet&proce***equest

@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

   proce***equest(request, response);
}

    protected final void proce***equest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // 系統計時開始時間
        long startTime = System.currentTimeMillis();
        Throwable failureCause = null;
        // 國際化
        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        LocaleContext localeContext = buildLocaleContext(request);
        //構建ServletRequestAttributes對象
        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
        //異步管理
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
        //初始化ContextHolders
        initContextHolders(request, localeContext, requestAttributes);

        try {
            doService(request, response);
        }
        catch (ServletException | IOException ex) {
            failureCause = ex;
            throw ex;
        }
        catch (Throwable ex) {
            failureCause = ex;
            throw new NestedServletException("Request processing failed", ex);
        }

        finally {
             //恢復原來的LocaleContext和ServiceRequestAttributes到LocaleContextHolder和RequestContextHolder，避免影響Servlet以外的處理，如Filter
            resetContextHolders(request, previousLocaleContext, previousAttributes);
            if (requestAttributes != null) {
                requestAttributes.requestCompleted();
            }
            logResult(request, response, failureCause, asyncManager);
            //發佈ServletRequestHandlerEvent消息，這個請求是否執行成功都會發布消息的
            publishRequestHandledEvent(request, response, startTime, failureCause);
        }
    }

// initContextHolders(request, localeContext, requestAttributes);
    private void initContextHolders(HttpServletRequest request,
            @Nullable LocaleContext localeContext, @Nullable RequestAttributes requestAttributes) {

        if (localeContext != null) {
            LocaleContextHolder.setLocaleContext(localeContext, this.threadContextInheritable);
        }
        if (requestAttributes != null) {
            RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);
        }
    }

該方法大概做了這幾件事：國際化的設置，創建 ServletRequestAttributes 對象，初始化上下文 holders （即將 Request 對象放入到線程上下文中，如後續想要在方法中獲取 request、response對象此時可以通過調用 LocaleContextHolder 對應方法即可），然後調用 doService 方法。對於 doService 方法，FrameworkServlet 類並未提供實現，該方法由 DispatcherServlet 子類實現：

DispatcherServlet#doService

DispatcherServlet 裏面執行處理的入口方法是 doService，由於這個類繼承於 FrameworkServlet 類，重寫了 doService() 方法：

@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
   logRequest(request);

   // Keep a snapshot of the request attributes in case of an include,
   // to be able to restore the original attributes after the include.
   Map<String, Object> attributesSnapshot = null;
   if (WebUtils.isIncludeRequest(request)) {
      attributesSnapshot = new HashMap<>();
      Enumeration<?> attrNames = request.getAttributeNames();
      while (attrNames.hasMoreElements()) {
         String attrName = (String) attrNames.nextElement();
         if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
            attributesSnapshot.put(attrName, request.getAttribute(attrName));
         }
      }
   }

    //Spring上下文
   request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    //國際化解析器
   request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
    //主題解析器
   request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
    //主題
   request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

    //重定向的數據  
   if (this.flashMapManager != null) {
      FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
      if (inputFlashMap != null) {
         request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
      }
      request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
      request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
   }

   try {
      //request設置完相關的屬性做真正的請求處理
      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);
         }
      }
   }
}

整個方法看下來處理的操作有：處理 include 標籤的請求，將上下文放到 request 的屬性中，將國際化解析器放到 request 的屬性中，將主題解析器放到 request 屬性中，將主題放到 request 的屬性中，處理重定向的請求數據最後調用 doDispatch 這個核心的方法對請求進行處理：

DispatcherServlet#doDispatch

該方法是在 doService 方法中調用的，從底層設計了整個請求的處理流程：

根據 request 找到 Handler
根據 Handler 找到對應的 HandlerAdapter
用 HandlerAdapter 處理 Handler
調用 processDispatchResult 方法處理上面之後的結果（包含View渲染並輸出給用戶）

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 {
          // 校驗是否爲上傳請求 是上傳請求執行解析 否則返回request
         processedRequest = checkMultipart(request);
         multipartRequestParsed = (processedRequest != request);

         // 根據訪問的Handler 返回指定對應的HandlerExecutionChain對象 這裏從HandlerMapping 集合中查找 HandlerExecutionChain 對象包含Handler與攔截器HandlerInterceptor列表
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null) {
            noHandlerFound(processedRequest, response);
            return;
         }

         // 根據得到的Handler 獲取對應的HandlerAdaptor對象
         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

         // 處理GET、HEAD請求的Last-Modified
         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;
            }
         }

         //執行Interceptor的preHandle 
         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
         }

         // 執行Handler 返回ModelAndView
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

          //如果需要異步處理，直接返回
         if (asyncManager.isConcurrentHandlingStarted()) {
            return;
         }

         //當view爲空時，根據request設置默認view，如Handler返回值爲void
         applyDefaultViewName(processedRequest, mv);
         //執行相應Interceptor的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);
      }
       //處理返回結果，包括處理異常、渲染頁面，發出完成通知觸發Interceptor的afterCompletion
      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()) {
         // 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);
         }
      }
   }
}

doDispatcher 首先檢查是不是上傳請求，如果是則將 request 轉換爲 MultipartHttpServletRequest，並將 multipartRequestParsed 標誌設置爲 true；
通過 getHandler 獲取 Handler 處理器鏈 HandlerExecutionChain；
處理GET、HEAD請求的 Last-Modified，這裏主要判斷 Last-Modified 值是否被修改來處理決定是否採用緩存數據；
接下來依次調用相應的 Interceptor 的 preHandle，執行攔截器攔截操作；
攔截器 preHandle 方法執行後，此時開始通過 HandlerAdapter 適配對應的 Handler 執行（這裏纔是真正要執行的 Controller 方法）， Handler 處理完請求後，如果需要異步處理則直接返回，如果不需要異步處理，當 view 爲空時，設置默認 view，然後執行相應的 Interceptor 的postHandle。

Handler：處理器，他直接對應着 MVC 中的 C，也就是 Controller 層，它的具體表現形式有很多，可以是類，也可以是方法（通常以方法居多），因爲它的定義是 Object，我們在方法中標註的 @RequestMapping 的所有方法都可以看成一個 Handler，只要可以實際處理請求的都可以看成 Handler。
HandlerMapping：用來查找 Handler，在 SpringMVC 中會處理很多請求，每一個請求都需要一個 Handler 來處理，具體接受到請求後需要哪一個 Handler 來處理，此時通過 HandlerMapping 來實現查找。
HandlerAdapter：適配器，不同的 Handler 需要找到不同 HandlerAdapter 來調用 Handler。就如工廠裏需要使用工具，工人（HandlerAdapter）使用工具（Handler）完成工作，而 HandlerMapping 用於根據需要完成的工作來找到相應的工具。

DispatcherServlet#processDispatchResult

processDispatchResult 方法主要用來處理前面返回的結果，其中包括處理異常、渲染頁面、觸發 Interceptor 的 afterCompletion 方法三部分內容，處理的異常是在處理請求 doDispatch 方法的過程中產生。

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
      @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
      @Nullable 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(mv, request, response);
      if (errorView) {
         WebUtils.clearErrorRequestAttributes(request);
      }
   }
   else {
      if (logger.isTraceEnabled()) {
         logger.trace("No view rendering, null ModelAndView returned.");
      }
   }

   if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
      // Concurrent handling started during a forward
      return;
   }

   // Handler請求處理完，觸發Interceptor的afterCompletion
   if (mappedHandler != null) {
      // Exception (if any) is already handled..
      mappedHandler.triggerAfterCompletion(request, response, null);
   }
}

render 視圖渲染：

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
   // Determine locale for request and apply it to the response.
   Locale locale =
         (this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
   response.setLocale(locale);

   View view;
   String viewName = mv.getViewName();
   if (viewName != null) {
      // We need to resolve the view name.
      view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
      if (view == null) {
         throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
               "' in servlet with name '" + getServletName() + "'");
      }
   }
   else {
      // No need to lookup: the ModelAndView object contains the actual View object.
      view = mv.getView();
      if (view == null) {
         throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
               "View object in servlet with name '" + getServletName() + "'");
      }
   }

   if (logger.isTraceEnabled()) {
      logger.trace("Rendering view [" + view + "] ");
   }
   try {
      if (mv.getStatus() != null) {
         response.setStatus(mv.getStatus().value());
      }
       // 渲染頁面處理
      view.render(mv.getModelInternal(), request, response);
   }
   catch (Exception ex) {
      if (logger.isDebugEnabled()) {
         logger.debug("Error rendering view [" + view + "]", ex);
      }
      throw ex;
   }
}

今天我們來了解了一下 SpringMVC 框架中 MVC 核心思想，SpringMVC 內部請求流程分析以及源碼級別代碼解讀，讓大家真正能夠從底層級別理解整個框架執行原貌，最後以一張圖來總結今天的源碼分析執行流程。

擴展~MVC

模型-視圖-控制器（MVC）是一個衆所周知的以設計界面應用程序爲基礎的設計思想。它主要通過分離模型、視圖及控制器在應用程序中的角色將業務邏輯從界面中解耦。通常，模型負責封裝應用程序數據在視圖層展示。視圖僅僅只是展示這些數據，不包含任何業務邏輯。控制器負責接收來自用戶的請求，並調用後臺服務（service或者dao）來處理業務邏輯。處理後，後臺業務層可能會返回了一些數據在視圖層展示。控制器收集這些數據及準備模型在視圖層展示。MVC模式的核心思想是將業務邏輯從界面中分離出來，允許它們單獨改變而不會相互影響。

SpringMVC到底是如何處理請求的？

請求流程的方式

案例實操

SpringMVC 請求執行源碼解讀

FrameworkServlet#service

HttpServlet#service

FrameworkServlet#doGet&proce***equest

DispatcherServlet#doService

DispatcherServlet#doDispatch

DispatcherServlet#processDispatchResult

擴展~MVC

[牛課習題]字符串中找出連續最長的數字串

Apache Druid 命令執行漏洞（CVE-2021-25646）復現

曙光大數據互聯網解決方案深掘數據價值開啓智能之旅

DNS分離解析——提高不同用戶訪問服務器的速度

SpringMVC到底是如何處理請求的？

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結