【Spring】MVC：源码流程（下）运行阶段

ゞ浴缸里的玫瑰 2022-10-31 12:20 94阅读 0赞

# 运行 #

**源码流程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70][]

**时序图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70 1]

## DispatchServlet ##

### doDispatch() ###

// 中央控制器,控制请求的转发 
    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 { 
             // 1.检查是否是文件上传的请求
             processedRequest = checkMultipart(request);
             multipartRequestParsed = (processedRequest != request);
    
             // Determine handler for the current request.
             // 2.取得处理当前请求的controller,这里也称为hanlder（处理器）
             // 第一个步骤的意义就在这里体现了.这里并不是直接返回controller,而是返回的HandlerExecutionChain请求处理器链对象,该对象封装了handler和interceptors.
             mappedHandler = getHandler(processedRequest);
             // 如果handler为空,则返回404
             if (mappedHandler == null) { 
                noHandlerFound(processedRequest, response);
                return;
             }
    
             // Determine handler adapter for the current request.
             // 3.获取处理request的处理器适配器handler adapter
             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
             // Process last-modified header, if supported by the handler.
             // 处理 last-modified 请求头
             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;
                }
             }
    		
    		 // 拦截器前置处理方法
             if (!mappedHandler.applyPreHandle(processedRequest, response)) { 
                return;
             }
    
             // Actually invoke the handler.
             // 4.实际的处理器处理请求,返回结果视图对象
             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
             if (asyncManager.isConcurrentHandlingStarted()) { 
                return;
             }
    		
    		 // 设置默认的 viewName
             applyDefaultViewName(processedRequest, mv);
             // 拦截器后置处理方法
             mappedHandler.applyPostHandle(processedRequest, response, mv);
          }
          catch (Exception ex) { 
             dispatchException = ex;
          }
          catch (Throwable err) { 
             // As of 4.3, we're processing Errors thrown from handler methods as well,
             // making them available for @ExceptionHandler methods and other scenarios.
             dispatchException = new NestedServletException("Handler dispatch failed", err);
          }
          
          // 结果视图对象的处理，并调用拦截器完成处理方法
          processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
       }
       catch (Exception ex) { 
          triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
       }
       catch (Throwable err) { 
          triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", 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);
             }
          }
       }
    }

getHandler(processedRequest)方法实际上就是从 HandlerMapping 中找到 url 和 Controller的对应关系。也就是Map<url,Controller>。我们知道，最终处理Request的是Controller中的方法，我们现在只是知道了Controller，我们如何确认Controller中处理Request的方法呢？继续往下看。

从Map<urls,beanName>中取得Controller 后，经过拦截器的预处理方法，再通过反射获取该方法上的注解和参数，解析方法和参数上的注解，然后反射调用方法获取ModelAndView 结果视图。最后，调用的就是 RequestMappingHandlerAdapter 的 handle()中的核心逻辑由 handleInternal(request, response, handler) 实现。

### handleInternal() ###

@Override
    protected ModelAndView handleInternal(HttpServletRequest request,
          HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { 
    
       ModelAndView mav;
       checkRequest(request);
    
       // Execute invokeHandlerMethod in synchronized block if required.
       if (this.synchronizeOnSession) { 
          HttpSession session = request.getSession(false);
          if (session != null) { 
             Object mutex = WebUtils.getSessionMutex(session);
             synchronized (mutex) { 
                mav = invokeHandlerMethod(request, response, handlerMethod);
             }
          }
          else { 
             // No HttpSession available -> no mutex necessary
             mav = invokeHandlerMethod(request, response, handlerMethod);
          }
       }
       else { 
          // No synchronization on session demanded at all...
          mav = invokeHandlerMethod(request, response, handlerMethod);
       }
    
       if (!response.containsHeader(HEADER_CACHE_CONTROL)) { 
          if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) { 
             applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
          }
          else { 
             prepareResponse(response);
          }
       }
    
       return mav;
    }

整个处理过程中最核心的逻辑其实就是拼接Controller的url和方法的url，与Request的url进行匹配，找到匹配的方法。

通过上面的代码分析，已经可以找到处理 Request 的 Controller 中的方法了，现在看如何解析该方法上的参数，并反射调用该方法。

### invokeHandlerMethod() ###

// 获取处理请求的方法,执行并返回结果视图 
    @Nullable
    protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
          HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { 
    
       ServletWebRequest webRequest = new ServletWebRequest(request, response);
       try { 
          WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
          ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
    
    	  // 真正执行的 handerMethod
          ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
          if (this.argumentResolvers != null) { 
             invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
          }
          if (this.returnValueHandlers != null) { 
             invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
          }
          invocableMethod.setDataBinderFactory(binderFactory);
          invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
    
          ModelAndViewContainer mavContainer = new ModelAndViewContainer();
          mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
          modelFactory.initModel(webRequest, mavContainer, invocableMethod);
          mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
    
          AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
          asyncWebRequest.setTimeout(this.asyncRequestTimeout);
    
          WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
          asyncManager.setTaskExecutor(this.taskExecutor);
          asyncManager.setAsyncWebRequest(asyncWebRequest);
          asyncManager.registerCallableInterceptors(this.callableInterceptors);
          asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
    
          if (asyncManager.hasConcurrentResult()) { 
             Object result = asyncManager.getConcurrentResult();
             mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
             asyncManager.clearConcurrentResult();
             if (logger.isDebugEnabled()) { 
                logger.debug("Found concurrent result value [" + result + "]");
             }
             invocableMethod = invocableMethod.wrapConcurrentResult(result);
          }
    	 
          // 完成 ServletInvocableHandlerMethod 的方法执行
          invocableMethod.invokeAndHandle(webRequest, mavContainer);
          if (asyncManager.isConcurrentHandlingStarted()) { 
             return null;
          }
    
          return getModelAndView(mavContainer, modelFactory, webRequest);
       }
       finally { 
          webRequest.requestCompleted();
       }
    }

## ServletInvocableHandlerMethod ##

### invokeAndHandle() ###

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
          Object... providedArgs) throws Exception { 
    	
    	// 执行请求，并返回结果
       Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
       setResponseStatus(webRequest);
    
       if (returnValue == null) { 
          if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) { 
             mavContainer.setRequestHandled(true);
             return;
          }
       }
       else if (StringUtils.hasText(getResponseStatusReason())) { 
          mavContainer.setRequestHandled(true);
          return;
       }
    
       mavContainer.setRequestHandled(false);
       Assert.state(this.returnValueHandlers != null, "No return value handlers");
       try { 
       	  // 对返回结果处理，处理结果会保存在 ModelAndViewController
          this.returnValueHandlers.handleReturnValue(
                returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
       }
       catch (Exception ex) { 
          if (logger.isTraceEnabled()) { 
             logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);
          }
          throw ex;
       }
    }

### invokeForRequest() ###

@Nullable
    public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
          Object... providedArgs) throws Exception { 
    	
    	// 获取参数列表
       Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
       if (logger.isTraceEnabled()) { 
          logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
                "' with arguments " + Arrays.toString(args));
       }
       // 执行方法
       Object returnValue = doInvoke(args);
       if (logger.isTraceEnabled()) { 
          logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
                "] returned [" + returnValue + "]");
       }
       return returnValue;
    }

到这里，方法的参数值列表也获取到了，就可以直接进行方法的调用了。整个请求过程中最复杂的一步就是在这里了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70]: /images/20221024/7f06870abba74f039857cf9395a9af45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70 1]: /images/20221024/d522a352cbe84d8ca0216517ba35db49.png