SpringMVC原始碼剖析（四）- DispatcherServlet請求轉發的實現

huidaoli發表於2013-08-01
SpringMVC原始碼Servlet

SpringMVC完成初始化流程之後，就進入Servlet標準生命週期的第二個階段，即“service”階段。在“service”階段中，每一次Http請求到來，容器都會啟動一個請求執行緒，通過service()方法，委派到doGet()或者doPost()這些方法，完成Http請求的處理。

在初始化流程中，SpringMVC巧妙的運用依賴注入讀取引數，並最終建立一個與容器上下文相關聯的Spring子上下文。這個子上下文，就像Struts2中xwork容器一樣，為接下來的Http處理流程中各種程式設計元素提供了容身之所。如果說將Spring上下文關聯到Servlet容器中，是SpringMVC框架的第一個亮點，那麼在請求轉發流程中，SpringMVC對各種處理環節程式設計元素的抽象，就是另外一個獨具匠心的亮點。

Struts2採取的是一種完全和Web容器隔離和解耦的事件機制。諸如Action物件、Result物件、Interceptor物件，這些都是完全脫離Servlet容器的程式設計元素。Struts2將資料流和事件處理完全剝離開來，從Http請求中讀取資料後，下面的事件處理流程就只依賴於這些資料，而完全不知道有Web環境的存在。

反觀SpringMVC，無論HandlerMapping物件、HandlerAdapter物件還是View物件，這些核心的介面所定義的方法中，HttpServletRequest和HttpServletResponse物件都是直接作為方法的引數出現的。這也就意味著，框架的設計者，直接將SpringMVC框架和容器繫結到了一起。或者說，整個SpringMVC框架，都是依託著Servlet容器元素來設計的。下面就來看一下，原始碼中是如何體現這一點的。

1.請求轉發的入口

就像任何一個註冊在容器中的Servlet一樣，DispatcherServlet也是通過自己的service()方法來接收和轉發Http請求到具體的doGet()或doPost()這些方法的。以一次典型的GET請求為例，經過HttpServlet基類中service()方法的委派，請求會被轉發到doGet()方法中。doGet()方法，在DispatcherServlet的父類FrameworkServlet類中被覆寫。

[java] view plaincopy
  1. @Override  
  2. protected final void doGet(HttpServletRequest request, HttpServletResponse response)  
  3.         throws ServletException, IOException {  
  4.   
  5.     processRequest(request, response);  
  6. }  

 

可以看到，這裡只是簡單的轉發到processRequest()這個方法。

[java] view plaincopy
  1. protected final void processRequest(HttpServletRequest request, HttpServletResponse response)  
  2.         throws ServletException, IOException {  
  3.   
  4.     long startTime = System.currentTimeMillis();  
  5.     Throwable failureCause = null;  
  6.   
  7.     // Expose current LocaleResolver and request as LocaleContext.  
  8.     LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();  
  9.     LocaleContextHolder.setLocaleContext(buildLocaleContext(request), this.threadContextInheritable);  
  10.   
  11.     // Expose current RequestAttributes to current thread.  
  12.     RequestAttributes previousRequestAttributes = RequestContextHolder.getRequestAttributes();  
  13.     ServletRequestAttributes requestAttributes = null;  
  14.     if (previousRequestAttributes == null || previousRequestAttributes.getClass().equals(ServletRequestAttributes.class)) {  
  15.         requestAttributes = new ServletRequestAttributes(request);  
  16.         RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);  
  17.     }  
  18.   
  19.     if (logger.isTraceEnabled()) {  
  20.         logger.trace("Bound request context to thread: " + request);  
  21.     }  
  22.   
  23.     try {  
  24.         doService(request, response);  
  25.     }  
  26.     catch (ServletException ex) {  
  27.         failureCause = ex;  
  28.         throw ex;  
  29.     }  
  30.     catch (IOException ex) {  
  31.         failureCause = ex;  
  32.         throw ex;  
  33.     }  
  34.     catch (Throwable ex) {  
  35.         failureCause = ex;  
  36.         throw new NestedServletException("Request processing failed", ex);  
  37.     }  
  38.   
  39.     finally {  
  40.         // Clear request attributes and reset thread-bound context.  
  41.         LocaleContextHolder.setLocaleContext(previousLocaleContext, this.threadContextInheritable);  
  42.         if (requestAttributes != null) {  
  43.             RequestContextHolder.setRequestAttributes(previousRequestAttributes, this.threadContextInheritable);  
  44.             requestAttributes.requestCompleted();  
  45.         }  
  46.         if (logger.isTraceEnabled()) {  
  47.             logger.trace("Cleared thread-bound request context: " + request);  
  48.         }  
  49.   
  50.         if (logger.isDebugEnabled()) {  
  51.             if (failureCause != null) {  
  52.                 this.logger.debug("Could not complete request", failureCause);  
  53.             }  
  54.             else {  
  55.                 this.logger.debug("Successfully completed request");  
  56.             }  
  57.         }  
  58.         if (this.publishEvents) {  
  59.             // Whether or not we succeeded, publish an event.  
  60.             long processingTime = System.currentTimeMillis() - startTime;  
  61.             this.webApplicationContext.publishEvent(  
  62.                     new ServletRequestHandledEvent(this,  
  63.                             request.getRequestURI(), request.getRemoteAddr(),  
  64.                             request.getMethod(), getServletConfig().getServletName(),  
  65.                             WebUtils.getSessionId(request), getUsernameForRequest(request),  
  66.                             processingTime, failureCause));  
  67.         }  
  68.     }  
  69. }  

程式碼有點長，理解的要點是以doService()方法為區隔，前一部分是將當前請求的Locale物件和屬性，分別設定到LocaleContextHolder和RequestContextHolder這兩個抽象類中的ThreadLocal物件中，也就是分別將這兩個東西和請求執行緒做了繫結。在doService()處理結束後，再恢復回請求前的LocaleContextHolder和RequestContextHolder，也即解除執行緒繫結。每次請求處理結束後，容器上下文都發布了一個ServletRequestHandledEvent事件，你可以註冊監聽器來監聽該事件。

可以看到，processRequest()方法只是做了一些執行緒安全的隔離，真正的請求處理，發生在doService()方法中。點開FrameworkServlet類中的doService()方法。

[java] view plaincopy
  1. protected abstract void doService(HttpServletRequest request, HttpServletResponse response)  
  2.         throws Exception;  

又是一個抽象方法，這也是SpringMVC類設計中的慣用伎倆：父類抽象處理流程，子類給予具體的實現。真正的實現是在DispatcherServlet類中。

讓我們接著看DispatcherServlet類中實現的doService()方法。

[java] view plaincopy
  1. @Override  
  2. protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  3.     if (logger.isDebugEnabled()) {  
  4.         String requestUri = urlPathHelper.getRequestUri(request);  
  5.         logger.debug("DispatcherServlet with name '" + getServletName() + "' processing " + request.getMethod() +  
  6.                 " request for [" + requestUri + "]");  
  7.     }  
  8.   
  9.     // Keep a snapshot of the request attributes in case of an include,  
  10.     // to be able to restore the original attributes after the include.  
  11.     Map<String, Object> attributesSnapshot = null;  
  12.     if (WebUtils.isIncludeRequest(request)) {  
  13.         logger.debug("Taking snapshot of request attributes before include");  
  14.         attributesSnapshot = new HashMap<String, Object>();  
  15.         Enumeration<?> attrNames = request.getAttributeNames();  
  16.         while (attrNames.hasMoreElements()) {  
  17.             String attrName = (String) attrNames.nextElement();  
  18.             if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {  
  19.                 attributesSnapshot.put(attrName, request.getAttribute(attrName));  
  20.             }  
  21.         }  
  22.     }  
  23.   
  24.     // Make framework objects available to handlers and view objects.  
  25.     request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());  
  26.     request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);  
  27.     request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);  
  28.     request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());  
  29.   
  30.     FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);  
  31.     if (inputFlashMap != null) {  
  32.         request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));  
  33.     }  
  34.     request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());  
  35.     request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);  
  36.   
  37.     try {  
  38.         doDispatch(request, response);  
  39.     }  
  40.     finally {  
  41.         // Restore the original attribute snapshot, in case of an include.  
  42.         if (attributesSnapshot != null) {  
  43.             restoreAttributesAfterInclude(request, attributesSnapshot);  
  44.         }  
  45.     }  
  46. }  

幾個requet.setAttribute()方法的呼叫，將前面在初始化流程中例項化的物件設定到http請求的屬性中，供下一步處理使用，其中有容器的上下文物件、本地化解析器等SpringMVC特有的程式設計元素。不同於Struts2中的ValueStack，SpringMVC的資料並沒有從HttpServletRequest物件中抽離出來再存進另外一個程式設計元素，這也跟SpringMVC的設計思想有關。因為從一開始，SpringMVC的設計者就認為，不應該將請求處理過程和Web容器完全隔離。

所以，你可以看到，真正發生請求轉發的方法doDispatch()中，它的引數是HttpServletRequest和HttpServletResponse物件。這給我們傳遞的意思也很明確，從request中能獲取到一切請求的資料，從response中，我們又可以往伺服器端輸出任何響應，Http請求的處理，就應該圍繞這兩個物件來設計。我們不妨可以將SpringMVC這種設計方案，是從Struts2的過度設計中吸取教訓，而向Servlet程式設計的一種迴歸和簡化。

2.請求轉發的抽象描述

接下來讓我們看看doDispatch()這個整個請求轉發流程中最核心的方法。DispatcherServlet所接收的Http請求，經過層層轉發，最終都是彙總到這個方法中來進行最後的請求分發和處理。doDispatch()這個方法的內容，就是SpringMVC整個框架的精華所在。它通過高度抽象的介面，描述出了一個MVC（Model-View-Controller）設計模式的實現方案。Model、View、Controller三種層次的程式設計元素，在SpringMVC中都有大量的實現類，各種處理細節也是千差萬別。但是，它們最後都是由，也都能由doDispatch()方法來統一描述，這就是介面和抽象的威力，萬變不離其宗。

先來看一下doDispatch()方法的廬山真面目。

 

[java] view plaincopy
  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  2.     HttpServletRequest processedRequest = request;  
  3.     HandlerExecutionChain mappedHandler = null;  
  4.     int interceptorIndex = -1;  
  5.   
  6.     try {  
  7.         ModelAndView mv;  
  8.         boolean errorView = false;  
  9.   
  10.         try {  
  11.             processedRequest = checkMultipart(request);  
  12.   
  13.             // Determine handler for the current request.  
  14.             mappedHandler = getHandler(processedRequest, false);  
  15.             if (mappedHandler == null || mappedHandler.getHandler() == null) {  
  16.                 noHandlerFound(processedRequest, response);  
  17.                 return;  
  18.             }  
  19.   
  20.             // Determine handler adapter for the current request.  
  21.             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
  22.   
  23.             // Process last-modified header, if supported by the handler.  
  24.             String method = request.getMethod();  
  25.             boolean isGet = "GET".equals(method);  
  26.             if (isGet || "HEAD".equals(method)) {  
  27.                 long lastModified = ha.getLastModified(request, mappedHandler.getHandler());  
  28.                 if (logger.isDebugEnabled()) {  
  29.                     String requestUri = urlPathHelper.getRequestUri(request);  
  30.                     logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);  
  31.                 }  
  32.                 if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {  
  33.                     return;  
  34.                 }  
  35.             }  
  36.   
  37.             // Apply preHandle methods of registered interceptors.  
  38.             HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();  
  39.             if (interceptors != null) {  
  40.                 for (int i = 0; i < interceptors.length; i++) {  
  41.                     HandlerInterceptor interceptor = interceptors[i];  
  42.                     if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {  
  43.                         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
  44.                         return;  
  45.                     }  
  46.                     interceptorIndex = i;  
  47.                 }  
  48.             }  
  49.   
  50.             // Actually invoke the handler.  
  51.             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  52.   
  53.             // Do we need view name translation?  
  54.             if (mv != null && !mv.hasView()) {  
  55.                 mv.setViewName(getDefaultViewName(request));  
  56.             }  
  57.   
  58.             // Apply postHandle methods of registered interceptors.  
  59.             if (interceptors != null) {  
  60.                 for (int i = interceptors.length - 1; i >= 0; i--) {  
  61.                     HandlerInterceptor interceptor = interceptors[i];  
  62.                     interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);  
  63.                 }  
  64.             }  
  65.         }  
  66.         catch (ModelAndViewDefiningException ex) {  
  67.             logger.debug("ModelAndViewDefiningException encountered", ex);  
  68.             mv = ex.getModelAndView();  
  69.         }  
  70.         catch (Exception ex) {  
  71.             Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
  72.             mv = processHandlerException(processedRequest, response, handler, ex);  
  73.             errorView = (mv != null);  
  74.         }  
  75.   
  76.         // Did the handler return a view to render?  
  77.         if (mv != null && !mv.wasCleared()) {  
  78.             render(mv, processedRequest, response);  
  79.             if (errorView) {  
  80.                 WebUtils.clearErrorRequestAttributes(request);  
  81.             }  
  82.         }  
  83.         else {  
  84.             if (logger.isDebugEnabled()) {  
  85.                 logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +  
  86.                         "': assuming HandlerAdapter completed request handling");  
  87.             }  
  88.         }  
  89.   
  90.         // Trigger after-completion for successful outcome.  
  91.         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
  92.     }  
  93.   
  94.     catch (Exception ex) {  
  95.         // Trigger after-completion for thrown exception.  
  96.         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
  97.         throw ex;  
  98.     }  
  99.     catch (Error err) {  
  100.         ServletException ex = new NestedServletException("Handler processing failed", err);  
  101.         // Trigger after-completion for thrown exception.  
  102.         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
  103.         throw ex;  
  104.     }  
  105.   
  106.     finally {  
  107.         // Clean up any resources used by a multipart request.  
  108.         if (processedRequest != request) {  
  109.             cleanupMultipart(processedRequest);  
  110.         }  
  111.     }  
  112. }  

真是千呼萬喚始出來，猶抱琵琶半遮面。我們在第一篇《SpringMVC原始碼剖析（一）- 從抽象和介面說起》中所描述的各種程式設計元素，依次出現在該方法中。HandlerMapping、HandlerAdapter、View這些介面的設計，我們在第一篇中已經講過。現在我們來重點關注一下HandlerExecutionChain這個物件。

從上面的程式碼中，很明顯可以看出一條線索，整個方法是圍繞著如何獲取HandlerExecutionChain物件，執行HandlerExecutionChain物件得到相應的檢視物件，再對檢視進行渲染這條主線來展開的。HandlerExecutionChain物件顯得異常重要。

因為Http請求要進入SpringMVC的處理體系，必須由HandlerMapping介面的實現類對映Http請求，得到一個封裝後的HandlerExecutionChain物件。再由HandlerAdapter介面的實現類來處理這個HandlerExecutionChain物件所包裝的處理物件，來得到最後渲染的檢視物件。

檢視物件是用ModelAndView物件來描述的，名字已經非常直白，就是資料和檢視，其中的資料，由HttpServletRequest的屬性得到，檢視就是由HandlerExecutionChain封裝的處理物件處理後得到。當然HandlerExecutionChain中的攔截器列表HandlerInterceptor，會在處理過程的前後依次被呼叫，為處理過程留下充足的擴充套件點。

所有的SpringMVC框架元素，都是圍繞著HandlerExecutionChain這個執行鏈來發揮效用。我們來看看，HandlerExecutionChain類的程式碼。

[java] view plaincopy
  1. package org.springframework.web.servlet;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Arrays;  
  5. import java.util.List;  
  6.   
  7. import org.springframework.util.CollectionUtils;  
  8.   
  9. public class HandlerExecutionChain {  
  10.   
  11.     private final Object handler;  
  12.   
  13.     private HandlerInterceptor[] interceptors;  
  14.   
  15.     private List<HandlerInterceptor> interceptorList;  
  16.   
  17.     public HandlerExecutionChain(Object handler) {  
  18.         this(handler, null);  
  19.     }  
  20.   
  21.     public HandlerExecutionChain(Object handler, HandlerInterceptor[] interceptors) {  
  22.         if (handler instanceof HandlerExecutionChain) {  
  23.             HandlerExecutionChain originalChain = (HandlerExecutionChain) handler;  
  24.             this.handler = originalChain.getHandler();  
  25.             this.interceptorList = new ArrayList<HandlerInterceptor>();  
  26.             CollectionUtils.mergeArrayIntoCollection(originalChain.getInterceptors(), this.interceptorList);  
  27.             CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);  
  28.         }  
  29.         else {  
  30.             this.handler = handler;  
  31.             this.interceptors = interceptors;  
  32.         }  
  33.     }  
  34.   
  35.     public Object getHandler() {  
  36.         return this.handler;  
  37.     }  
  38.   
  39.     public void addInterceptor(HandlerInterceptor interceptor) {  
  40.         initInterceptorList();  
  41.         this.interceptorList.add(interceptor);  
  42.     }  
  43.   
  44.     public void addInterceptors(HandlerInterceptor[] interceptors) {  
  45.         if (interceptors != null) {  
  46.             initInterceptorList();  
  47.             this.interceptorList.addAll(Arrays.asList(interceptors));  
  48.         }  
  49.     }  
  50.   
  51.     private void initInterceptorList() {  
  52.         if (this.interceptorList == null) {  
  53.             this.interceptorList = new ArrayList<HandlerInterceptor>();  
  54.         }  
  55.         if (this.interceptors != null) {  
  56.             this.interceptorList.addAll(Arrays.asList(this.interceptors));  
  57.             this.interceptors = null;  
  58.         }  
  59.     }  
  60.   
  61.     public HandlerInterceptor[] getInterceptors() {  
  62.         if (this.interceptors == null && this.interceptorList != null) {  
  63.             this.interceptors = this.interceptorList.toArray(new HandlerInterceptor[this.interceptorList.size()]);  
  64.         }  
  65.         return this.interceptors;  
  66.     }  
  67.   
  68.     @Override  
  69.     public String toString() {  
  70.         if (this.handler == null) {  
  71.             return "HandlerExecutionChain with no handler";  
  72.         }  
  73.         StringBuilder sb = new StringBuilder();  
  74.         sb.append("HandlerExecutionChain with handler [").append(this.handler).append("]");  
  75.         if (!CollectionUtils.isEmpty(this.interceptorList)) {  
  76.             sb.append(" and ").append(this.interceptorList.size()).append(" interceptor");  
  77.             if (this.interceptorList.size() > 1) {  
  78.                 sb.append("s");  
  79.             }  
  80.         }  
  81.         return sb.toString();  
  82.     }  
  83.   
  84. }  

一個攔截器列表，一個執行物件，這個類的內容十分的簡單，它蘊含的設計思想，卻十分的豐富。

1.攔截器組成的列表，在執行物件被呼叫的前後，會依次執行。這裡可以看成是一個的AOP環繞通知，攔截器可以對處理物件隨心所欲的進行處理和增強。這裡明顯是吸收了Struts2中攔截器的設計思想。這種AOP環繞式的擴充套件點設計，也幾乎成為所有框架必備的內容。

2.實際的處理物件，即handler物件，是由Object物件來引用的。

[java] view plaincopy
  1. private final Object handler;  

之所以要用一個java世界最基礎的Object物件引用來引用這個handler物件，是因為連特定的介面也不希望繫結在這個handler物件上，從而使handler物件具有最大程度的選擇性和靈活性。

我們常說，一個框架最高層次的抽象是介面，但是這裡SpringMVC更進了一步。在最後的處理物件上面，SpringMVC沒有對它做任何的限制，只要是java世界中的物件，都可以用來作為最後的處理物件，來生成檢視。極端一點來說，你甚至可以將另外一個MVC框架整合到SpringMVC中來，也就是為什麼SpringMVC官方文件中，居然還有整合其他表現層框架的內容。這一點，在所有表現層框架中，是獨領風騷，冠絕群雄的。

3.結語

SpringMVC的成功，源於它對開閉原則的運用和遵守。也正因此，才使得整個框架具有如此強大的描述和擴充套件能力。這也許和SpringMVC出現和興起的時間有關，正是經歷了Struts1到Struts2這些Web開發領域MVC框架的更新換代，它的設計者才能站在前人的肩膀上。知道了如何將事情做的糟糕之後，你或許才知道如何將事情做得好。

希望在這個系列裡面分享的SpringMVC原始碼閱讀經驗，能幫助讀者們從更高的層次來審視SpringMVC框架的設計，也希望這裡所描述的一些基本設計思想，能在你更深入的瞭解SpringMVC的細節時，對你有幫助。哲學才是唯一的、最終的武器，在一個框架的設計上，尤其是如此。經常地體會一個框架設計者的設計思想，對你更好的使用它，是有莫大的益處的。

相關文章