面試官：你分析過SpringMVC的源碼嗎？

時間 2019-12-09

原文原文鏈接

1. MVC使用

在研究源碼以前，先來回顧如下springmvc 是如何配置的，這將能使咱們更容易理解源碼。html

1.1 web.xml

 1 <servlet>
 2     <servlet-name>mvc-dispatcher</servlet-name>
 3     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 4     <!-- 配置springMVC須要加載的配置文件
 5         spring-dao.xml,spring-service.xml,spring-web.xml
 6         Mybatis - > spring -> springmvc
 7      -->
 8     <init-param>
 9         <param-name>contextConfigLocation</param-name>
10         <param-value>classpath:spring/spring-*.xml</param-value>
11     </init-param>
12 </servlet>
13 <servlet-mapping>
14     <servlet-name>mvc-dispatcher</servlet-name>
15     <!-- 默認匹配全部的請求 -->
16     <url-pattern>/</url-pattern>
17 </servlet-mapping>

值的注意的是contextConfigLocation和DispatcherServlet(用此類來攔截請求)的引用和配置。前端

1.2 spring-web.xml

 1 <!-- 配置SpringMVC -->
 2 <!-- 1.開啓SpringMVC註解模式 -->
 3 <!-- 簡化配置： 
 4     (1)自動註冊DefaultAnootationHandlerMapping,AnotationMethodHandlerAdapter 
 5     (2)提供一些列：數據綁定，數字和日期的format @NumberFormat, @DateTimeFormat, xml,json默認讀寫支持 
 6 -->
 7 <mvc:annotation-driven />
 8 
 9 <!-- 2.靜態資源默認servlet配置
10     (1)加入對靜態資源的處理：js,gif,png
11     (2)容許使用"/"作總體映射
12  -->
13  <mvc:default-servlet-handler/>
14 
15  <!-- 3.配置jsp 顯示ViewResolver -->
16  <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
17      <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
18      <property name="prefix" value="/WEB-INF/jsp/" />
19      <property name="suffix" value=".jsp" />
20  </bean>
21 
22  <!-- 4.掃描web相關的bean -->
23  <context:component-scan base-package="com.xxx.fantj.web" />

值的注意的是InternalResourceViewResolver，它會在ModelAndView返回的試圖名前面加上prefix前綴，在後面加載suffix指定後綴。git

SpringMvc主支源碼分析

引用《Spring in Action》中的一張圖來更好的瞭解執行過程： github

上圖流程整體來講可分爲三大塊：web

Map的創建(並放入WebApplicationContext)spring
HttpRequest請求中Url的請求攔截處理(DispatchServlet處理)json
反射調用Controller中對應的處理方法，並返回視圖後端

本文將圍繞這三塊進行分析。api

1. Map的創建

在容器初始化時會創建全部 url 和 Controller 的對應關係,保存到 Map<url,controller>中，那是如何保存的呢。數組

ApplicationObjectSupport #setApplicationContext方法

1 // 初始化ApplicationContext
2 @Override
3 public void initApplicationContext() throws ApplicationContextException {
4     super.initApplicationContext();
5     detectHandlers();
6 }

AbstractDetectingUrlHandlerMapping #detectHandlers()方法：

 1 /**
 2  * 創建當前ApplicationContext 中的 全部Controller 和url 的對應關係
 3  * Register all handlers found in the current ApplicationContext.
 4  * <p>The actual URL determination for a handler is up to the concrete
 5  * {@link #determineUrlsForHandler(String)} implementation. A bean for
 6  * which no such URLs could be determined is simply not considered a handler.
 7  * @throws org.springframework.beans.BeansException if the handler couldn't be registered
 8  * @see #determineUrlsForHandler(String)
 9  */
10 protected void detectHandlers() throws BeansException {
11     if (logger.isDebugEnabled()) {
12         logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
13     }
14     // 獲取容器中的beanNames
15     String[] beanNames = (this.detectHandlersInAncestorContexts ?
16             BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
17             getApplicationContext().getBeanNamesForType(Object.class));
18     // 遍歷 beanNames 並找到對應的 url
19     // Take any bean name that we can determine URLs for.
20     for (String beanName : beanNames) {
21         // 獲取bean上的url(class上的url + method 上的 url)
22         String[] urls = determineUrlsForHandler(beanName);
23         if (!ObjectUtils.isEmpty(urls)) {
24             // URL paths found: Let's consider it a handler.
25             // 保存url 和 beanName 的對應關係
26             registerHandler(urls, beanName);
27         }
28         else {
29             if (logger.isDebugEnabled()) {
30                 logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
31             }
32         }
33     }
34 }

determineUrlsForHandler()方法：

該方法在不一樣的子類有不一樣的實現，我這裏分析的是DefaultAnnotationHandlerMapping類的實現，該類主要負責處理@RequestMapping註解形式的聲明。

 1 /**
 2  * 獲取@RequestMaping註解中的url
 3  * Checks for presence of the {@link org.springframework.web.bind.annotation.RequestMapping}
 4  * annotation on the handler class and on any of its methods.
 5  */
 6 @Override
 7 protected String[] determineUrlsForHandler(String beanName) {
 8     ApplicationContext context = getApplicationContext();
 9     Class<?> handlerType = context.getType(beanName);
10     // 獲取beanName 上的requestMapping
11     RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);
12     if (mapping != null) {
13         // 類上面有@RequestMapping 註解
14         this.cachedMappings.put(handlerType, mapping);
15         Set<String> urls = new LinkedHashSet<String>();
16         // mapping.value()就是獲取@RequestMapping註解的value值
17         String[] typeLevelPatterns = mapping.value();
18         if (typeLevelPatterns.length > 0) {
19             // 獲取Controller 方法上的@RequestMapping
20             String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType);
21             for (String typeLevelPattern : typeLevelPatterns) {
22                 if (!typeLevelPattern.startsWith("/")) {
23                     typeLevelPattern = "/" + typeLevelPattern;
24                 }
25                 for (String methodLevelPattern : methodLevelPatterns) {
26                     // controller的映射url+方法映射的url
27                     String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern);
28                     // 保存到set集合中
29                     addUrlsForPath(urls, combinedPattern);
30                 }
31                 addUrlsForPath(urls, typeLevelPattern);
32             }
33             // 以數組形式返回controller上的全部url
34             return StringUtils.toStringArray(urls);
35         }
36         else {
37             // controller上的@RequestMapping映射url爲空串,直接找方法的映射url
38             return determineUrlsForHandlerMethods(handlerType);
39         }
40     }
41     // controller上沒@RequestMapping註解
42     else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) {
43         // 獲取controller中方法上的映射url
44         return determineUrlsForHandlerMethods(handlerType);
45     }
46     else {
47         return null;
48     }
49 }

更深的細節代碼就比較簡單了，有興趣的能夠繼續深刻。

到這裏，Controller和Url的映射就裝配完成，下來就分析請求的處理過程。

2. url的請求處理

咱們在xml中配置了DispatcherServlet爲調度器，因此咱們就來看它的代碼，能夠
從名字上看出它是個Servlet,那麼它的核心方法就是doService()

DispatcherServlet #doService():

 1 /**
 2  * 將DispatcherServlet特定的請求屬性和委託 公開給{@link #doDispatch}以進行實際調度。
 3  * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
 4  * for the actual dispatching.
 5  */
 6 @Override
 7 protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
 8     if (logger.isDebugEnabled()) {
 9         String requestUri = new UrlPathHelper().getRequestUri(request);
10         logger.debug("DispatcherServlet with name '" + getServletName() + "' processing " + request.getMethod() +
11                 " request for [" + requestUri + "]");
12     }
13 
14     //在包含request的狀況下保留請求屬性的快照，
15     //可以在include以後恢復原始屬性。
16     Map<String, Object> attributesSnapshot = null;
17     if (WebUtils.isIncludeRequest(request)) {
18         logger.debug("Taking snapshot of request attributes before include");
19         attributesSnapshot = new HashMap<String, Object>();
20         Enumeration attrNames = request.getAttributeNames();
21         while (attrNames.hasMoreElements()) {
22             String attrName = (String) attrNames.nextElement();
23             if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
24                 attributesSnapshot.put(attrName, request.getAttribute(attrName));
25             }
26         }
27     }
28 
29     // 使得request對象能供 handler處理和view處理 使用
30     request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
31     request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
32     request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
33     request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
34 
35     try {
36         doDispatch(request, response);
37     }
38     finally {
39         // 若是不爲空，則還原原始屬性快照。
40         if (attributesSnapshot != null) {
41             restoreAttributesAfterInclude(request, attributesSnapshot);
42         }
43     }
44 }

能夠看到，它將請求拿到後，主要是給request設置了一些對象，以便於後續工做的處理(Handler處理和view處理)。好比WebApplicationContext，它裏面就包含了咱們在第一步完成的controller與url映射的信息。

DispatchServlet # doDispatch()

  1 /**
  2  * 控制請求轉發
  3  * Process the actual dispatching to the handler.
  4  * <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
  5  * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
  6  * to find the first that supports the handler class.
  7  * <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
  8  * themselves to decide which methods are acceptable.
  9  * @param request current HTTP request
 10  * @param response current HTTP response
 11  * @throws Exception in case of any kind of processing failure
 12  */
 13 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
 14     HttpServletRequest processedRequest = request;
 15     HandlerExecutionChain mappedHandler = null;
 16     int interceptorIndex = -1;
 17 
 18     try {
 19 
 20         ModelAndView mv;
 21         boolean errorView = false;
 22 
 23         try {
 24             // 1. 檢查是不是上傳文件
 25             processedRequest = checkMultipart(request);
 26 
 27             // Determine handler for the current request.
 28             // 2. 獲取handler處理器，返回的mappedHandler封裝了handlers和interceptors
 29             mappedHandler = getHandler(processedRequest, false);
 30             if (mappedHandler == null || mappedHandler.getHandler() == null) {
 31                 // 返回404
 32                 noHandlerFound(processedRequest, response);
 33                 return;
 34             }
 35 
 36             // Apply preHandle methods of registered interceptors.
 37             // 獲取HandlerInterceptor的預處理方法
 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             // 3. 獲取handler適配器 Adapter
 52             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 53             // 4. 實際的處理器處理並返回 ModelAndView 對象
 54             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
 55 
 56             // Do we need view name translation?
 57             if (mv != null && !mv.hasView()) {
 58                 mv.setViewName(getDefaultViewName(request));
 59             }
 60 
 61             // HandlerInterceptor 後處理
 62             if (interceptors != null) {
 63                 for (int i = interceptors.length - 1; i >= 0; i--) {
 64                     HandlerInterceptor interceptor = interceptors[i];
 65                     // 結束視圖對象處理
 66                     interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
 67                 }
 68             }
 69         }
 70         catch (ModelAndViewDefiningException ex) {
 71             logger.debug("ModelAndViewDefiningException encountered", ex);
 72             mv = ex.getModelAndView();
 73         }
 74         catch (Exception ex) {
 75             Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
 76             mv = processHandlerException(processedRequest, response, handler, ex);
 77             errorView = (mv != null);
 78         }
 79 
 80         // Did the handler return a view to render?
 81         if (mv != null && !mv.wasCleared()) {
 82             render(mv, processedRequest, response);
 83             if (errorView) {
 84                 WebUtils.clearErrorRequestAttributes(request);
 85             }
 86         }
 87         else {
 88             if (logger.isDebugEnabled()) {
 89                 logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
 90                         "': assuming HandlerAdapter completed request handling");
 91             }
 92         }
 93 
 94         // Trigger after-completion for successful outcome.
 95         // 請求成功響應以後的方法
 96         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
 97     }
 98 
 99     catch (Exception ex) {
100         // Trigger after-completion for thrown exception.
101         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
102         throw ex;
103     }
104     catch (Error err) {
105         ServletException ex = new NestedServletException("Handler processing failed", err);
106         // Trigger after-completion for thrown exception.
107         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
108         throw ex;
109     }
110 
111     finally {
112         // Clean up any resources used by a multipart request.
113         if (processedRequest != request) {
114             cleanupMultipart(processedRequest);
115         }
116     }
117 }

該方法主要是

經過request對象獲取到HandlerExecutionChain，HandlerExecutionChain對象裏面包含了攔截器interceptor和處理器handler。若是獲取到的對象是空，則交給noHandlerFound返回404頁面。
攔截器預處理，若是執行成功則進行3
獲取handler適配器 Adapter
實際的處理器處理並返回 ModelAndView 對象

下面是該方法中的一些核心細節：

DispatchServlet #doDispatch # noHandlerFound核心源碼：

response.sendError(HttpServletResponse.SC_NOT_FOUND);

DispatchServlet #doDispatch #getHandler方法事實上調用的是AbstractHandlerMapping #getHandler方法,我貼出一個核心的代碼：

1 // 拿處處理對象
2 Object handler = getHandlerInternal(request);
3 ...
4 String handlerName = (String) handler;
5 handler = getApplicationContext().getBean(handlerName);
6 ...
7 // 返回HandlerExecutionChain對象
8 return getHandlerExecutionChain(handler, request);

能夠看到，它先從request裏獲取handler對象，這就證實了以前DispatchServlet #doService爲何要吧WebApplicationContext放入request請求對象中。

最終返回一個HandlerExecutionChain對象.

3. 反射調用處理請求的方法，返回結果視圖

在上面的源碼中，實際的處理器處理並返回 ModelAndView 對象調用的是mv = ha.handle(processedRequest, response, mappedHandler.getHandler());這個方法。該方法由AnnotationMethodHandlerAdapter #handle() #invokeHandlerMethod()方法實現.

`AnnotationMethodHandlerAdapter #handle() #invokeHandlerMethod()`

 1 /**
 2  * 獲取處理請求的方法,執行並返回結果視圖
 3  */
 4 protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
 5         throws Exception {
 6 
 7     // 1.獲取方法解析器
 8     ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
 9     // 2.解析request中的url,獲取處理request的方法
10     Method handlerMethod = methodResolver.resolveHandlerMethod(request);
11     // 3. 方法調用器
12     ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
13     ServletWebRequest webRequest = new ServletWebRequest(request, response);
14     ExtendedModelMap implicitModel = new BindingAwareModelMap();
15     // 4.執行方法（獲取方法的參數）
16     Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
17     // 5. 封裝成mv視圖
18     ModelAndView mav =
19             methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
20     methodInvoker.updateModelAttributes(handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);
21     return mav;
22 }

這個方法有兩個重要的地方，分別是resolveHandlerMethod和invokeHandlerMethod。

resolveHandlerMethod 方法

methodResolver.resolveHandlerMethod(request):獲取controller類和方法上的@requestMapping value,與request的url進行匹配,找處處理request的controller中的方法.最終拼接的具體實現是org.springframework.util.AntPathMatcher#combine方法。

invokeHandlerMethod方法

從名字就能看出來它是基於反射，那它作了什麼呢。

解析該方法上的參數,並調用該方法。

1 //上面全都是爲解析方法上的參數作準備
2 ...
3 // 解析該方法上的參數
4 Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
5 // 真正執行解析調用的方法
6 return doInvokeMethod(handlerMethodToInvoke, handler, args);

invokeHandlerMethod方法#resolveHandlerArguments方法

代碼有點長，我就簡介下它作了什麼事情吧。

若是這個方法的參數用的是註解，則解析註解拿到參數名，而後拿到request中的參數名，二者一致則進行賦值(詳細代碼在HandlerMethodInvoker#resolveRequestParam)，而後將封裝好的對象放到args[]的數組中並返回。
若是這個方法的參數用的不是註解，則須要asm框架(底層是讀取字節碼)來幫助獲取到參數名，而後拿到request中的參數名，二者一致則進行賦值，而後將封裝好的對象放到args[]的數組中並返回。

invokeHandlerMethod方法#doInvokeMethod方法

 1 private Object doInvokeMethod(Method method, Object target, Object[] args) throws Exception {
 2     // 將一個方法設置爲可調用，主要針對private方法
 3     ReflectionUtils.makeAccessible(method);
 4     try {
 5         // 反射調用
 6         return method.invoke(target, args);
 7     }
 8     catch (InvocationTargetException ex) {
 9         ReflectionUtils.rethrowException(ex.getTargetException());
10     }
11     throw new IllegalStateException("Should never get here");
12 }

到這裏,就能夠對request請求中url對應的controller的某個對應方法進行調用了。

總結：

看完後腦子必定很亂，有時間的話仍是須要本身動手調試一下。本文只是串一下總體思路，因此功能性的源碼沒有所有分析。

其實理解這些纔是最重要的。

用戶發送請求至前端控制器DispatcherServlet
DispatcherServlet收到請求調用HandlerMapping處理器映射器。
處理器映射器根據請求url找到具體的處理器，生成處理器對象及處理器攔截器(若是有則生成)一併返回給DispatcherServlet。
DispatcherServlet經過HandlerAdapter處理器適配器調用處理器
HandlerAdapter執行處理器(handler，也叫後端控制器)。
Controller執行完成返回ModelAndView
HandlerAdapter將handler執行結果ModelAndView返回給DispatcherServlet
DispatcherServlet將ModelAndView傳給ViewReslover視圖解析器
ViewReslover解析後返回具體View對象
DispatcherServlet對View進行渲染視圖（即將模型數據填充至視圖中）。
DispatcherServlet響應用戶

參考文獻：

https://github.com/fangjian0423/springmvc-source-minibook
https://docs.spring.io/spring/docs/4.0.2.RELEASE/spring-framework-reference/htmlsingle/#mvc-ann-requestmapping
https://translate.google.cn/