SpringMVC源碼剖析（一）

1、處理過程分析

一、首先，Tomcat每次啓動時都會加載並解析/WEB-INF/web.xml文件，因此能夠先從web.xml找突破口，主要代碼以下：

<servlet >
    <servlet-name >spring-mvc</servlet-name>
    <!-- servlet類 -->
    <servlet-class >org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 初始化參數 -->
    <init-param >
      <param-name >contextConfigLocation</param-name>
      <param-value >classpath:/spring-mvc.xml</param-value>
    </init-param>
    <!-- 啓動時加載 -->
    <load-on-startup >1</load-on-startup>
  </servlet>
  <servlet-mapping >
    <servlet-name >spring-mvc</servlet-name>
    <url-pattern >/</url-pattern>
  </servlet-mapping>
   .
   .
   .
</servlet >

咱們能夠從web.xml文件得到三個信息，分別是：servlet類爲DispatcherServlet，它在啓動時加載，加載時初始化參數contextConfigLocation 
爲classpath下spring-mvc.xml的文件地址，接下來咱們將目光移到DispatcherServlet類。

二、打開DispatcherServlet類，咱們先將目光聚焦在它的結構體系上，以下圖：

很明顯，它是一個Servlet的子類，其實不用說也知道，由於web.xml早已有配置。既然是Servlet，咱們就要專一於它的service、doGet、doPost等相關方法，在它的父類FrameServlet，咱們找到了service方法。

/**
     * Override the parent class implementation in order to intercept PATCH
     * requests.
     */
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        String method = request.getMethod();
        if (method.equalsIgnoreCase(RequestMethod.PATCH.name())) {
            processRequest(request, response);
        }
        else {
            super.service(request, response);
        }
    }

根據service方法，咱們一步步找到一個方法鏈service –> processRequest –> doService –> doDispatch，咱們最終將目光定位在doDispatch，由於從它的方法體就能夠看出它是整個SpringMVC的核心方法。

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;

                // 解析請求，獲取HandlerExecutionChain對象
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 從HandlerExecutionChain對象獲取HandlerAdapter對象，其實是從HandlerMapping對象中獲取
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.
                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;
                    }
                }

                //在controller方法執行前，執行攔截器的相關方法（pre）
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                try {
                    // 執行HandlerAdapter對象的handler方法，返回ModelAndView
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                }
                finally {
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
                }

                applyDefaultViewName(request, mv);
                //在controller方法執行後，執行攔截器的相關方法（post）
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            //進行視圖解析
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Error err) {
            triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                return;
            }
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }

說它是核心一點也不爲過，從上述代碼的中文註釋能夠看出，它包含了解析請求，執行相關攔截器，執行handle方法（到這裏關於handle方法是什麼，咱們一臉懵逼。別急，接下來咱們會講述，總之它很重要就對了），執行視圖解析方法。 
三、至於HandlerAdapter是幹嗎用的？它的handler方法有什麼用？咱們毫無概念，接下來咱們從另外一個角度切入（就像兩我的相對而行，一我的筋疲力盡了，惟有靠另外一我的努力前行才能相遇），因此我選擇Controller，得先從配置文件入手，由於它採用了spring的IOC。

<bean id="controller" class="com.mvc.controller.MyController"></bean>

    <bean id="interceptor" class="com.mvc.interceptor.MyInterceptor"></bean>

    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="controller">controller</prop>
            </props>
        </property>
        <property name="interceptors">
            <array>
                <ref bean="interceptor"></ref>
            </array>
        </property>
    </bean>

配置文件又給了咱們一條重要的信息：controller和攔截器都是做爲SimpleUrlHandlerMapping的參數傳進去的，而SimpleUrlHandlerMapping是HandlerMapping的子類。從這裏就能夠猜想，controller的核心方法要麼被HandlerMapping直接調用，要麼被HandlerMapping的附屬產品（類）進行調用，接下來咱們查看一下controller核心方法的調用狀況。

很幸運，看到SimpleControllerHandlerAdapter和DispatcherServlet.doDispatch(request, response),我好像發現了新大陸，這不正是咱們想要的嗎？HandlerAdapter類和doDispatch(request, response)方法完美地結合在了一塊兒。再看SimpleControllerHandlerAdapter的handler方法：

@Override
    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {

        return ((Controller) handler).handleRequest(request, response);
    }

這裏也有一個方法的調用鏈，從上圖就能夠看出，handle方法最終是調用handleRequestInternal方法，也就是咱們在controller中自定義的方法。總而言之，HandlerAdapter的handler方法是用來調用controller中的handleRequestInternal方法的，而handleRequestInternal的方法體正是咱們用戶自定義的業務邏輯。 
好，SpringMVC的主要源碼咱們就解析到這裏了，接下來咱們就SpringMVC的處理過程作一個總結。

2、SpringMVC處理過程總結
    先放一張圖，咱們再慢慢解析：
流程解析：  一、當request到來時，DispatcherServlet對request進行捕獲，並執行doService方法，繼而執行doDispatch方法。  二、HandlerMapping解析請求，而且返回HandlerExecutionChain（其中包含controllers和interceptors），而後經過HandlerExecutionChain獲得Handler相關類，根據Handler獲取執行它的HandlerAdapter類。  三、先執行攔截器的pre相關方法，接着執行handler方法，它會調用controller的handleRequestInternal方法（方法體由用戶自定義），最後調用攔截器的post相關方法。  四、解析handler方法返回的ModelAndView（能夠在配置文件中配置ResourceViewResolver，也就是視圖解析器），渲染頁面並response給客戶端。