6、SpringMVC源碼分析（1）：分析DispatcherServlet.doDispatch方法，了解總體流程

 

所有的http請求都會交給DispatcherServlet類的doDispatch方法進行處理，將DispatcherServlet.doDispatch函數的javadoc復制到下面：

/*
     * Process the actual dispatching to the handler.
     * 
     * The handler will be obtained by applying the servlet's HandlerMappings in
     * order.The HandlerAdapter will be obtained by querying the servlet's
     * installed HandlerAdapters to find the first that supports the handler
     * class.
     * 
     * All HTTP methods are handled by this method. It's up to HandlerAdapters
     * or handlers themselves to decide which methods are acceptable.
     */
     void org.springframework.web.servlet.DispatcherServlet.doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception;

 

下面分析doDispatch方法的流程，采用注釋源碼的方式：

protected void doDispatch(HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        
        // processedRequest是經過checkMultipart方法處理過的request請求
        HttpServletRequest processedRequest = request;
        /**
         * Handler execution chain, consisting of handler object and any handler
         * interceptors. Returned by HandlerMapping's HandlerMapping.getHandler
         * method. 看看HandlerExecutionChain類的屬性就很清楚了：
         * 
          public class HandlerExecutionChain {
         
                  private final Object handler; //這個就是和該請求對應的handler處理方法
         
                 //里面記錄了所有的(any handler interceptors)和該請求相關的攔截器
                  private HandlerInterceptor[] interceptors;
          
                  private List<HandlerInterceptor> interceptorList; 
         
                  private int interceptorIndex = -1; 
                      
                  //... 
          }
         * 
         */
        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);

                // Determine handler for the current request.Return a handler
                // and any interceptors for this request.
                /*
                 * 得到的mappedHandler包含一個請求的handler處理方法以及與該請求相關的所有攔截器
                 * 
                 * DispatcherServlet.getHandler方法會在底層調用HandlerMapping.getHandler方法
                 * ，這個方法中會遍 歷DispatcherServlet中的private List<HandlerMapping>
                 * handlerMappings鏈表，找到能夠處理當前 request請求的第一個HandlerMapping實例並返回：
                 * 
                  protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
                      for (HandlerMapping hm : this.handlerMappings) {
                              HandlerExecutionChain handler = hm.getHandler(request);
                              if (handler != null) {
                                     return handler;
                              }
                      }
                      return null;
                  }
                 *
                 */
                mappedHandler = getHandler(processedRequest);
                // 如果沒有找到和該請求相對應的mappedHandler，那么就會直接返回，並應答noHandlerFound異常
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // Determine handler adapter for the current request.
                /*
                 * HandlerAdapter: 它是一個接口public interface HandlerAdapter
                 * 看看源碼上的說明：The DispatcherServlet accesses all installed
                 * handlers through this interface, meaning that it does not
                 * contain code specific to any handler type.
                 * 
                 * 從后面的源碼看出，在使用@RequestMapping注解標注handler方法的時候，獲取到的是HandlerAdapter的
                 * RequestMappingHandlerAdapter實現類的一個對象。
                 * 
                 * 可以看看DispatcherServlet.getHandlerAdapter方法的定義，這個對理解上回很有幫助，我們會發現
                 * ，getHandlerAdapter 方法和上面提到的getHandler方法一樣都是尋找第一個可用的作為返回結果：
                 *
                 * 
                  protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
                     //this.handlerAdapters的定義是 private List<HandlerAdapter> handlerAdapters
                         for (HandlerAdapter ha : this.handlerAdapters) { 
                              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");
                  }
                 * 
                 */
                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;
                    }
                }

                // Apply preHandle methods of registered interceptors.
                /*
                 * 會調用所有注冊攔截器的preHandle方法，如果preHandle方法的返回結果為true，則會繼續執行下面的程序，
                 * 否則會直接返回。
                 * 
                 * 分析一下HandlerExecutionChain.applyPreHandle方法的源碼 ：
                  boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
                         //從上面的HandlerExecutionChain定義處可以看見有個interceptors，還有一個interceptorList。不知道有什么區別？？！
                         HandlerInterceptor[] interceptors = getInterceptors();
                         //如果已經注冊有攔截器，則遍歷攔截器
                         if (!ObjectUtils.isEmpty(interceptors)) {
                             for (int i = 0; i < interceptors.length; i++) {
                                 HandlerInterceptor interceptor = interceptors[i];
                                 //如果注冊攔截器的preHandle方法返回一個false，則該applyPreHandle方法就會返回false，從而在doDispatcher中的代碼就不會往下執行了
                                 if (!interceptor.preHandle(request, response, this.handler)) {
                                     
                                     //這個方法要注意，它會調用所有已經成功執行的攔截器的afterCompletion方法，而且是反序調用的過程，可以分析triggerAfterCompletion
                                     //的源代碼，主要是利用interceptorIndex反減的方式實現的。下面是源碼的英文注釋：
                                     //Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
                                      //Will just invoke afterCompletion for all interceptors whose preHandle invocation
                                      //has successfully completed and returned true.
                                     triggerAfterCompletion(request, response, null);
                                     return false;
                             }
                                 //沒成功執行一個攔截器的preHandle方法，其interceptorIndex就會增加1；原始值為-1。
                                  this.interceptorIndex = i;
                             }
                         }
                         return true;
                     }
                 *
                 *
                 *  順帶看看triggerAfterCompletion的源代碼，很容易理解為什么攔截器的afterCompletion方法是反序執行的：
                 *    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)
                             throws Exception {
                
                        HandlerInterceptor[] interceptors = 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 ex2) {
                                    logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
                                }
                            }
                        }
                    }
                 *
                 *
                 */
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // Actually invoke the handler.
                /*
                 * 在這個函數里面會真正的執行request請求相對於的handler方法，可以想象：在真正調用方法之前還會有很多的
                 * 先前處理。在這里僅僅是分析出大概的代碼執行流程，其細節的部分在后面的單獨模塊源碼分析的時候做詳細的講解。
                 * 上面講解到HandlerAdapter是一個接口：public interface HandlerAdapter，那么必然會有很多
                 * 中實現類，在采用注解@RequstMapping的方式標注handler的情況下，ha.handle方法會在底層調用具體的
                 * HandlerAdapter類實現方法RequestMappingHandlerAdapter.handleInternal
                 * 
                 * 分析一下RequestMappingHandlerAdapter.handleInternal的源代碼：
                      protected ModelAndView handleInternal(HttpServletRequest request,
                        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
                        //好像是看control的類定義處是否使用了@SessionAttributes注解，checkAndPrepare方法有什么作用？？？
                        if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
                            // Always prevent caching in case of session attribute management.
                            checkAndPrepare(request, response, this.cacheSecondsForSessionAttributeHandlers, true);
                        }
                        else {
                            // Uses configured default cacheSeconds setting.
                            checkAndPrepare(request, response, true);
                        }
                        
                        // Execute invokeHandlerMethod in synchronized block if required.
                        // 這里是個值得注意的地方，synchronizeOnSession的值默認為false，如果通過某個方法使得其為true，那么request對應的handler
                        // 將會被放在同步快中進行處理。在什么時機下，使用什么方法才能將其設置為true呢？？？
                        if (this.synchronizeOnSession) {
                            HttpSession session = request.getSession(false);
                            if (session != null) {
                                Object mutex = WebUtils.getSessionMutex(session);
                                // 將handler放在同步塊中處理
                                synchronized (mutex) {
                                    return invokeHandleMethod(request, response, handlerMethod);
                                }
                            }
                        }
                        //在invokeHandleMethod中會①將所有標注有@ModelAttrib的方法都執行一遍，②調用invokeAndHandle(webRequest, mavContainer)
                        //方法，在這里面調用handler方法，③最后調用getModelAndView(mavContainer, modelFactory, webRequest)方法的到ModelAndView。
                        //invokeHandleMethod這個方法還有很多東西要分析，留在后面。
                        //從上面的③我們可以看出，無論handler采用哪種模型化處理方式，最后都是將結果轉化為ModelAndView
                        return invokeHandleMethod(request, response, handlerMethod);
                    }
                 */
                mv = ha.handle(processedRequest, response,
                        mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                applyDefaultViewName(request, mv);
                /*
                 * 調用request相關的攔截器的postHandle方法，注意，這個也是反序調用的。看看源代碼：
                 *
                  void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
                        HandlerInterceptor[] interceptors = getInterceptors();
                        if (!ObjectUtils.isEmpty(interceptors)) {
                            //注意，這里也是反序執行，而且是所有成功執行了的postHandle攔截器
                            for (int i = interceptors.length - 1; i >= 0; i--) {
                                HandlerInterceptor interceptor = interceptors[i];
                                //這里傳入的參數中有mv，也就是說，我們是有辦法在攔截器的postHandle方法中修改已經返回的mv
                                interceptor.postHandle(request, response, this.handler, mv);
                            }
                        }
                    }
                 */
                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
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(
                            processedRequest, response);
                }
            } else {
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

 

看完源代碼就可以總結出doDispath方法中處理http請求的流程了：