SpringMVC的工作流程及原理詳解

什么是SpringMVC?

Spring MVC是一種基於Java的實現了MVC設計模式的、請求驅動類型的、輕量級Web框架。Spring MVC屬於SpringFrameWork的后續產品，已經融合在Spring Web Flow里面。Spring 框架提供了構建 Web 應用程序的全功能 MVC 模塊。SpringMVC是一種web層的mvc框架，用於替代servlet（處理響應請求，獲取表單參數，表單驗證等）。

工作流程圖

我個人整理的詳細流程圖：

工作流程詳解

1.由客戶端發起請求，到達中央控制器，一般我們配置DispatcherServlet如下：

    <!-- Spring MVC servlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--此參數可以不配置，默認值為：/WEB-INF/springmvc-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <!--web.xml 3.0的新特性，是否支持異步-->
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

2.中央控制器DispatcherServlet根據請求URI進行解析，找到相應的HandlerMapping(處理器映射器)，而HandlerMapping是項目啟動就保存在中央控制器中的集合內，我們可以通過源碼看到：

 所有的屬性都有自己的初始化init方法：

 3.DispatcherServlet通過HandlerMapping獲取到相應的HandlerExecutionChain(一個執行鏈對象),發生在getHandler方法內部，未找到就返回空進入另外的操作：

    @Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
            Iterator var2 = this.handlerMappings.iterator();

            while(var2.hasNext()) {
                HandlerMapping hm = (HandlerMapping)var2.next();
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Testing handler map [" + hm + "] in DispatcherServlet with name '" + this.getServletName() + "'");
                }

                HandlerExecutionChain handler = hm.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }

        return null;
    }

4.然后中央控制器DispatcherServlet根據HandlerExecutionChain內的Handler(執行器)對象來匹配相應的HandlerAdapter(處理器適配器)，這一步發生在getHandlerAdapter方法內：

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
            Iterator var2 = this.handlerAdapters.iterator();

            while(var2.hasNext()) {
                HandlerAdapter ha = (HandlerAdapter)var2.next();
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Testing handler adapter [" + ha + "]");
                }

                if (ha.supports(handler)) {
                    return ha;
                }
            }
        }

        throw new ServletException("No adapter for handler [" + handler + "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
    }

5.適配器(HandlerAdapter)執行handle方法將HandlerExecutionChain內的執行器(Handler)運行(也就是我們寫的Controller)，並且返回一個ModelAndView模型視圖對象：

//mv就是上面定義的ModelAndView對象，mappedHandler就是上面說的HandlerExecutionChain對象
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

6.中央控制器將接收到的ModelAndView對象進行檢查，實際調用的是HandlerInterceptor(處理器攔截器)的postHandle方法：

//注意這個方法是在HandlerExcutionChain類中，調用applyPostHandle檢查視圖是否存有異常
void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {
        HandlerInterceptor[] interceptors = this.getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for(int i = interceptors.length - 1; i >= 0; --i) {
                HandlerInterceptor interceptor = interceptors[i];
                interceptor.postHandle(request, response, this.handler, mv);
            }
        }

    }

7.上一步沒有異常進入視圖解析工作，中央控制器將ModelAndView交給視圖解析器(View)進行解析(拼接路徑，指向視圖)，並且返回一個真正的View也就是我們的頁面。

8.中央控制器接收到View進行數據渲染，填充數據，這兩步發生在processDispatchResult方法內：

    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) {
                this.logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException)exception).getModelAndView();
            } else {
                Object handler = mappedHandler != null ? mappedHandler.getHandler() : null;
                mv = this.processHandlerException(request, response, handler, exception);
                errorView = mv != null;
            }
        }

        if (mv != null && !mv.wasCleared()) {
            this.render(mv, request, response);
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        } else if (this.logger.isDebugEnabled()) {
            this.logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + this.getServletName() + "': assuming HandlerAdapter completed request handling");
        }

        if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            if (mappedHandler != null) {
                mappedHandler.triggerAfterCompletion(request, response, (Exception)null);
            }

        }
    }

9.如果是並發處理，則進行最后的檢查，最終響應到客戶端，完成一次請求響應。

    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) throws Exception {
        HandlerInterceptor[] interceptors = this.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 var8) {
                    logger.error("HandlerInterceptor.afterCompletion threw exception", var8);
                }
            }
        }

    }

DispatcherServlet主要操作都發生在doDispatch方法內部：

    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;//request
        HandlerExecutionChain mappedHandler = null;//執行鏈
        boolean multipartRequestParsed = false;//驗證是否文件流請求
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);//異步請求管理器

        try {
            try {
                ModelAndView mv = null;//模型視圖
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request);//檢查是否文件上傳相關
                    multipartRequestParsed = processedRequest != request;//驗證請求對象
                    mappedHandler = this.getHandler(processedRequest);//獲取執行鏈
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());//根據執行鏈中的Handler對象獲取對應的適配器
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if (isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if (this.logger.isDebugEnabled()) {
                            this.logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                        }

                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }

                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }

                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());//執行Handler返回模型視圖，也就是我們的Controller
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);//補充邏輯視圖名
                    mappedHandler.applyPostHandle(processedRequest, response, mv);//執行攔截器的postHandle方法
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);//最后渲染工作，最終
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            //檢查異步請求
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }    

重要組件功能

1. 前端控制器(DispatcherServlet)：接收請求，響應結果，相當於轉發器，調度其他組件、分發任務，中央處理器
2. 請求到處理器映射(HandlerMapping)：根據請求的url查找Handler
3. 處理器適配器(HandlerAdapter)：按照特定規則（HandlerAdapter要求的規則）去執行Handler
4. 視圖解析器(ViewResolver)：進行視圖解析，根據邏輯視圖名解析成真正的視圖(view)
5. 處理器或頁面控制器(Handler)：執行具體的用戶請求，也就是我們的業務Controller
6. 驗證器(Validator)：驗證數據安全
7. 命令對象(command object)：請求參數綁定到的對象就叫命令對象
8. 表單對象(form object)：請求表單數據對象

SpringMVC特點

• 清晰的角色划分：控制器（controller）、驗證器（validator）、 命令對象（command object）、表單對象（formobject）、模型對象（model object）、 Servlet分發器（DispatcherServlet）、處理器映射（handler mapping）、視圖解析器（view resolver）等。每一個角色都可以由一個專門的對象來實現。
• 強大而直接的配置方式：將框架類和應用程序類都能作為JavaBean配置，支持跨多個context的引用，例如，在web控制器中對業務對象和驗證器（validator）的引用。
• 可適配、非侵入：可以根據不同的應用場景，選擇合適的控制器子類 （simple型、command型、form型、wizard型、multi-action型或者自定義），而不是從單一控制器 （比如Action/ActionForm）繼承。
• 可重用的業務代碼：可以使用現有的業務對象作為命令或表單對象，而不需要去擴展某個特定框架的基類。
• 可定制的綁定（binding） 和驗證（validation）：比如將類型不匹配作為應用級的驗證錯誤， 這可以保存錯誤的值。再比如本地化的日期和數字綁定等等。在其他某些框架中，你只能使用字符串表單對象，需要手動解析它並轉換到業務對象。
• 可定制的handlermapping和view resolution：Spring提供從最簡單的URL映射， 到復雜的、專用的定制策略。與某些webMVC框架強制開發人員使用單一特定技術相比，Spring顯得更加靈活。
• 靈活的model轉換：在Springweb框架中，使用基於Map的 鍵/值對來達到輕易地與各種視圖技術的集成。
• 可定制的本地化和主題（theme）解析：支持在JSP中可選擇地使用Spring標簽庫、支持JSTL、支持Velocity（不需要額外的中間層）等等。
• 簡單而強大的JSP標簽庫（SpringTag Library）：支持包括諸如數據綁定和主題（theme） 之類的許多功能。
• JSP表單標簽庫：在Spring2.0中引入的表單標簽庫，使得在JSP中編寫 表單更加容易。
• Spring Bean的生命周期可以被限制在當前的HTTP Request或者HTTP Session。