【Spring】MVC：源码分析（下）运行阶段

￡神魔★判官ぃ 2022-12-28 00:44 142阅读 0赞

在[上一篇][Link 1]我们分析了 SpringMVC 初始阶段的源码，这篇我们就来看看执行阶段做了些什么。还是先看一眼运行时序图。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]

这一步是由请求触发的，所以入口为 DispatcherServlet 的核心方法为 doService()，doService()中的核心逻辑由doDispatch()实现，源代码如下：

### 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;
             }
    
             // 结果视图对象的处理
             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);
    
          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);
          }
    	 
          // 完成参数绑定
          invocableMethod.invokeAndHandle(webRequest, mavContainer);
          if (asyncManager.isConcurrentHandlingStarted()) {
        
             return null;
          }
    
          return getModelAndView(mavContainer, modelFactory, webRequest);
       }
       finally {
        
          webRequest.requestCompleted();
       }
    }

invocableMethod.invokeAndHandle()最终要实现的目的就是，完成 Request 中的参数和方法参数上数据的绑定。Spring MVC中提供两种Request参数到方法中参数的绑定方式：

1.  通过 @RequestParam 注解进行绑定
2.  通过参数名称进行绑定

使用注解进行绑定，我们只要在方法参数前面声明@RequestParam(“name”)，就可以将request中参数name的值绑定到方法的该参数上。使用参数名称进行绑定的前提是必须要获取方法中参数的名称，Java反射只提供了获取方法的参数的类型，并没有提供获取参数名称的方法。SpringMVC解决这个问题的方法是用asm框架读取字节码文件，来获取方法的参数名称。

> asm框架是一个字节码操作框架，关于asm更多介绍可以参考其官网。建议使用注解来完成参数绑定，这样就可以省去asm框架的读取字节码的操作。

### 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 {
        
          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;
    }

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

[Link 1]: https://blog.csdn.net/weixin_43935927/article/details/110927964
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/c4db2ca9326f4717ac02cd97786cd73d.png