Spring5源码14-SpringMVC-DispatcherServlet处理请求核心逻辑

1,383 阅读15分钟

欢迎大家关注 github.com/hsfxuebao ,希望对大家有所帮助,要是觉得可以的话麻烦给点一下Star哈

1. Spring mvc 流程

其时序图:

image.png

整体流程图: image.png

SpringMVC 工作流程描述:

  1. 用户向服务器发送请求,请求被Spring 前端控制Servelt DispatcherServlet捕获;
  2. DispatcherServlet对请求URL进行解析,得到请求资源标识符(URI)。然后根据该URI,调用HandlerMapping获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器),最后以HandlerExecutionChain对象的形式返回;
  3. DispatcherServlet 根据获得的Handler,选择一个合适的HandlerAdapter。(附注:如果成功获得HandlerAdapter后,此时将开始执行拦截器的preHandler(…)方法)
  4. 提取Request中的模型数据,填充Handler入参,开始执行Handler(Controller)。 在填充Handler的入参过程中,根据你的配置,Spring将帮你做一些额外的工作:
    • HttpMessageConveter: 将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定的响应信息
    • 数据转换:对请求消息进行数据转换。如String转换成Integer、Double等
    • 数据根式化:对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
    • 数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中
  5. Handler执行完成后,向DispatcherServlet 返回一个ModelAndView对象;
  6. 根据返回的ModelAndView,选择一个适合的ViewResolver(必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet
  7. ViewResolver 结合ModelView,来渲染视图
  8. 将渲染结果返回给客户端。

2. HttpServlet & FrameworkServlet

下面我们先看看 DispatcherServlet 的两个父类: HttpServletFrameworkServlet

image.png

FrameworkServlet 重写了 HttpServletservice 方法。 我们这里先来看看 FrameworkServlet#service 方法。

@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
        // 解析请求方式
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
                processRequest(request, response);
        }
        else {
                super.service(request, response);
        }
}

这里我们需要关注两个点 : processRequest(request, response);super.service(request, response);。下面我们一一来看

2.1 HttpServlet#service

我们知道 HttpServlet 类中分别提供了相应的服务方法(doGet、doPost等),如下图

image.png

同时,HttpServlet 会根据请求的不同形式引导到对应导函数中处理,如下 HttpServlet#service(HttpServletRequest, HttpServletResponse)

protected void service(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {

    String method = req.getMethod();
            // 如果是 get 方法
    if (method.equals(METHOD_GET)) {
            //  lastModified  缓存判断
        long lastModified = getLastModified(req);
        if (lastModified == -1) {
            // servlet doesn't support if-modified-since, no reason
            // to go through further expensive logic
            doGet(req, resp);
        } else {
            // 如果设置了缓存时间,则判断在ifModifiedSince  之后的时间,是否被修改。
            long ifModifiedSince;
            try {
                ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
            } catch (IllegalArgumentException iae) {
                // Invalid date header - proceed as if none was set
                ifModifiedSince = -1;
            }
            if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                // If the servlet mod time is later, call doGet()
                // Round down to the nearest second for a proper compare
                // A ifModifiedSince of -1 will always be less
                maybeSetLastModified(resp, lastModified);
                doGet(req, resp);
            } else {
                resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            }
        }

    }
    // 分发不同的请求
    else if (method.equals(METHOD_HEAD)) {
        long lastModified = getLastModified(req);
        maybeSetLastModified(resp, lastModified);
        doHead(req, resp);

    } else if (method.equals(METHOD_POST)) {
        doPost(req, resp);

    } else if (method.equals(METHOD_PUT)) {
        doPut(req, resp);

    } else if (method.equals(METHOD_DELETE)) {
        doDelete(req, resp);

    } else if (method.equals(METHOD_OPTIONS)) {
        doOptions(req,resp);

    } else if (method.equals(METHOD_TRACE)) {
        doTrace(req,resp);

    } else {
        //
        // Note that this means NO servlet supports whatever
        // method was requested, anywhere on this server.
        String errMsg = lStrings.getString("http.method_not_implemented");
        Object[] errArgs = new Object[1];
        errArgs[0] = method;
        errMsg = MessageFormat.format(errMsg, errArgs);

        resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
    }
}

而这几个函数最常用的就是 doGet()doPost() 。这两个方法被 FrameworkServlet 重写了。我们来看看在 FrameworkServlet 中的实现。

@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {

        processRequest(request, response);
}

@Override
protected final void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {

        processRequest(request, response);
}
... 

我们可以很清楚的看到,对于大部分的请求,还是依赖于 HttpServlet#service(HttpServletRequest, HttpServletResponse) 来进行一个请求的分发。对于我们常见的 doGet()doPost() 方法都是直接调用 processRequest(request, response);, 而processRequest方法 的具体实现在FrameworkServlet#processRequest 中 。

2.2 FrameworkServlet#processRequest

因此。接下来我们就来看看 org.springframework.web.servlet.FrameworkServlet#processRequest:

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

   // 记录当前时间,用于记录web请求的记录时间
   long startTime = System.currentTimeMillis();
   Throwable failureCause = null;

   // 1234 的目的是为了保证当前线程的 LocaleContext 和 RequestAttributes 在当前请求后还能恢复,所以提取保存
   // 1. 提取当前线程的 LocaleContext  属性
   LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
   // 2. 根据当前的request 创建对应的 LocaleContext ,并绑定到当前线程
   LocaleContext localeContext = buildLocaleContext(request);

   // 3. 提取当前线程的 RequestAttributes 属性
   RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
   // 4. 根据当前的request 创建对应的 RequestAttributes ,并绑定到当前线程
   ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

   WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
   asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

   initContextHolders(request, localeContext, requestAttributes);

   try {
      // todo 5. 委托给 doservice方法进行进一步处理
      doService(request, response);
   }
   catch (ServletException | IOException ex) {
      failureCause = ex;
      throw ex;
   }
   catch (Throwable ex) {
      failureCause = ex;
      throw new NestedServletException("Request processing failed", ex);
   }

   finally {
      // 6. 请求结束,恢复线程原状
      resetContextHolders(request, previousLocaleContext, previousAttributes);
      if (requestAttributes != null) {
         requestAttributes.requestCompleted();
      }
      logResult(request, response, failureCause, asyncManager);
      // 发布请求结束的通知事件,无论成功与否
      publishRequestHandledEvent(request, response, startTime, failureCause);
   }
}

由于逻辑都被封装到 doService(request, response); 中,所以这里还是比较简单。而doService又被 DispatcherServlet实现了。因此我们这里来看看 DispatcherServlet#doService

  1. DispatcherServlet#doService
@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
   logRequest(request);

   // Keep a snapshot of the request attributes in case of an include,
   // to be able to restore the original attributes after the include.
   Map<String, Object> attributesSnapshot = null;
   if (WebUtils.isIncludeRequest(request)) {
      attributesSnapshot = new HashMap<>();
      Enumeration<?> attrNames = request.getAttributeNames();
      while (attrNames.hasMoreElements()) {
         String attrName = (String) attrNames.nextElement();
         if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
            attributesSnapshot.put(attrName, request.getAttribute(attrName));
         }
      }
   }

   // Make framework objects available to handlers and view objects.
   // 基本的东西保存到request作用域中 方便获取, 设置一些Spring 上下文
   request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
   request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
   request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
   request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

   // 闪存管理器,重定向携带数据
   if (this.flashMapManager != null) {
      FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
      if (inputFlashMap != null) {
         request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
      }
      request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
      request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
   }

   RequestPath previousRequestPath = null;
   if (this.parseRequestPath) {
      previousRequestPath = (RequestPath) request.getAttribute(ServletRequestPathUtils.PATH_ATTRIBUTE);
      ServletRequestPathUtils.parseAndCache(request);
   }

   try {
      // todo 派发功能
      doDispatch(request, response);
   }
   finally {
      if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
         // Restore the original attribute snapshot, in case of an include.
         if (attributesSnapshot != null) {
            restoreAttributesAfterInclude(request, attributesSnapshot);
         }
      }
      if (this.parseRequestPath) {
         ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
      }
   }
}

很显然,这 “爷仨” 一层一层传递,终于传递到了DispatcherServlet 手里,这里我们直接开始看doDispatch(request, response);,这里才是核心逻辑的所在。

3. DispatcherServlet#doDispatch

// SpringMVC处理请求的核心流程
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   HttpServletRequest processedRequest = request;
   // handler (目标方法)的执行链
   HandlerExecutionChain mappedHandler = null;
   // 文件上传标志
   boolean multipartRequestParsed = false;

   // 对异步请求的支持(Servlet3.0 以后才有的,Webflux)
   WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

   try {
      ModelAndView mv = null;
      Exception dispatchException = null;

      try {
         // 1. 如果是 MultipartContent 类型的request 则转换request 为 MultipartHttpServletRequest 类型的request
         // 检查  当前是否文件上传的请求
         processedRequest = checkMultipart(request);
         multipartRequestParsed = (processedRequest != request);

         // Determine handler for the current request.
         // 2. 根据request 寻找对应的 handler
         // todo 构造出了【目标方法+拦截器整个链路】  决定使用哪个Handler处理当前请求
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null) {
            // 3. 如果没有找到对应的handler,则通过 response 反馈错误信息
            // 如果找不到处理,就报404错误
            noHandlerFound(processedRequest, response);
            return;
         }

         // Determine handler adapter for the current request.
         // 4. 根据当前的 handler 找到对应的HandlerAdapter
         // todo 获取适配器
         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

         // Process last-modified header, if supported by the handler.
         // 5. last-modified 的缓存处理
         // 如果当前handler 支持 last-modified 头处理则进行缓存处理
         String method = request.getMethod();
         boolean isGet = HttpMethod.GET.matches(method);
         // 如果是 get请求或者 head 请求则进入该分支
         if (isGet || HttpMethod.HEAD.matches(method)) {
            // todo 调用 HandlerAdapter#getLastModified 方法 来获取最后修改时间
            long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
            // todo 判断到目前为止是否有过修改,没有则直接return。实现缓存的功能
            if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
               return;
            }
         }

         // 6.1 执行 所有拦截器 的preHandle 方法,使用mappedHandler整个链
         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
         }

         // Actually invoke the handler.
         // todo 7. 真正执行目标方法,mappedHandler.getHandler() 并 返回视图
         // 反射执行目标方法,确定参数值,处理返回值【封装成ModelAndView】
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

         // // 8. 视图名称转换应用于需要添加前缀的情况 默认的ViewName
         applyDefaultViewName(processedRequest, mv);
         // 6.2 执行 所有拦截器 的postHandle 方法,使用mappedHandler整个链
         mappedHandler.applyPostHandle(processedRequest, response, mv);
      }
      catch (Exception ex) {
         // 记录下来异常,在 9 中统一处理
         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);
      }
      // todo 9. 处理最后的结果
      processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
   }
   catch (Exception ex) {
      // // 6.3 拦截器完成方法的调用 下面的即使执行完了,异常还是抛出去
      triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
   }
   catch (Throwable err) {
      // 6.3 拦截器完成方法的调用
      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);
         }
      }
   }
}

DispatcherServlet#doDispatch 涉及的地方就比较多,下面我们一个一个看:

3.1 checkMultipart(request)

对于请求的处理,Spring首先考虑的是对 Multipart 的处理,如果是 MultipartContent 类型的request 则转换request 为 MultipartHttpServletRequest 类型的request。简单来说,就是判断是否是文件请求。

protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
   // multipartResolver 文件上传解析器 isMultipart方法
   if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
      if (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null) {
         if (DispatcherType.REQUEST.equals(request.getDispatcherType())) {
            logger.trace("Request already resolved to MultipartHttpServletRequest, e.g. by MultipartFilter");
         }
      }
      else if (hasMultipartException(request)) {
         logger.debug("Multipart resolution previously failed for current request - " +
               "skipping re-resolution for undisturbed error rendering");
      }
      else {
         try {
            return this.multipartResolver.resolveMultipart(request);
         }
         catch (MultipartException ex) {
            if (request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) != null) {
               logger.debug("Multipart resolution failed for error dispatch", ex);
               // Keep processing error dispatch with regular request handle below
            }
            else {
               throw ex;
            }
         }
      }
   }
   // If not returned before: return original request.
   return request;
}

核心方法this.multipartResolver.isMultipart(request),我们来看一StandardServletMultipartResolver#isMultipart:

@Override
public boolean isMultipart(HttpServletRequest request) {
   // 所有文件上传请求都会有这个
   return StringUtils.startsWithIgnoreCase(request.getContentType(),
         (this.strictServletCompliance ? MediaType.MULTIPART_FORM_DATA_VALUE : "multipart/"));
}

3.2 getHandler(processedRequest);

这一步的目的是 根据request 信息遍历 HandlerMapping 找到对应的handler。 具体代码如下:

// DispatcherServlet#getHandler
@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	// 这里的 this.handlerMappings 在没有手动调整的情况下是加载的默认配置文件中的数据
	if (this.handlerMappings != null) {
		// 遍历每一个 handleMapping,解析 request,直到碰到一个解析成功的,将解析后的 Handler拦截链路返回。
		for (HandlerMapping mapping : this.handlerMappings) {
			HandlerExecutionChain handler = mapping.getHandler(request);
			if (handler != null) {
				return handler;
			}
		}
	}
	return null;
}

关于 mapping.getHandler(request) 的处理。后面详细介绍。

3.3 noHandlerFound(processedRequest, response);

正常情况下,每一个请求都应该对应一个 Handler,因为每个请求都应该在后台有对应的处理逻辑。而逻辑的实现就是在Handler 中。正常情况下,如果没有URL匹配的Handler,我们可以通过设置默认的Handler 来解决这一问题,不过如果没有设置默认的Handler。则只能通过Response 向用户返回错误信息。

protected void noHandlerFound(HttpServletRequest request, HttpServletResponse response) throws Exception {
        if (pageNotFoundLogger.isWarnEnabled()) {
                pageNotFoundLogger.warn("No mapping for " + request.getMethod() + " " + getRequestUri(request));
        }
        // 判断DispatcherServlet 属性设置,是否需要抛出异常
        if (this.throwExceptionIfNoHandlerFound) {
                throw new NoHandlerFoundException(request.getMethod(), getRequestUri(request),
                                new ServletServerHttpRequest(request).getHeaders());
        }
        else {
                // 否则直接抛出错误 404
                response.sendError(HttpServletResponse.SC_NOT_FOUND);
        }
}

3.4 getHandlerAdapter(mappedHandler.getHandler());

这一步的目的是根据 Handler 寻找对应的 HandlerAdapter。这里使用了适配器模式,遍历所有的 Adapter。根据 HandlerAdapter#supports 方法来判断是否支持当前Handler 的解析,如果支持,则返回。

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
                for (HandlerAdapter adapter : this.handlerAdapters) {
                        if (adapter.supports(handler)) {
                                return adapter;
                        }
                }
        }
        throw new ServletException("No adapter for handler [" + handler +
                        "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

我们这里返回的是RequestMappingHandlerAdapter,其判定条件如下:

@Override
public final boolean supports(Object handler) {
        // 	supportsInternal((HandlerMethod) handler)) 返回 true
        return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
}

3.5 Last-Modified 的缓存处理

在客户端第一次输入 URL 时,服务器端返回内容和200状态码,表示请求成功,同时会添加一个 “Last-Modified” 的响应头,表示此文件在服务器上最后的更新时间。

客户端第二次请求此URL时2,客户端会向服务器发送请求头 “If-Modified-Since”,询问服务器该时间之后当前请求是否有被修改过,如果服务端内容没有变化,则会自动返回 304 状态码(只要响应头,内容为空,这样就节省了带宽)。

Spring 实现 Last-Modified 机制,只需要实现 LastModified 接口就可以。如下:

@Component public class BeanNameSayController implements Controller, LastModified { private long lastModified;

@Override
public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
    return new ModelAndView("/hello");
}

@Override
public long getLastModified(HttpServletRequest request) {
    if (lastModified == 0L){
        lastModified = System.currentTimeMillis();
    }
    return lastModified;
}

}

后面具体分析。

3.6 拦截器的调用

我们添加的拦截器,会在下面这些地方被调用合适的方法。

3.6.1 mappedHandler.applyPreHandle(processedRequest, response)

逻辑很简单,遍历所有的拦截器,分别调用 preHandle 前置方法。

// org.springframework.web.servlet.HandlerExecutionChain#applyPreHandle
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 获取所有的拦截器
        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
                for (int i = 0; i < interceptors.length; i++) {
                        HandlerInterceptor interceptor = interceptors[i];
                        // 调用前置方法。如果有一个前置方法返回false,则直接调用完成方法
                        if (!interceptor.preHandle(request, response, this.handler)) {
                                triggerAfterCompletion(request, response, null);
                                return false;
                        }
                        this.interceptorIndex = i;
                }
        }
        return true;
}

3.6.2. mappedHandler.applyPostHandle(processedRequest, response, mv);

逻辑基本相同,没有什么区别,这里调用的是程序执行后的后置方法

// org.springframework.web.servlet.HandlerExecutionChain#applyPostHandle
void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
                throws Exception {

        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
                for (int i = interceptors.length - 1; i >= 0; i--) {
                        HandlerInterceptor interceptor = interceptors[i];
                        // 调用后置方法
                        interceptor.postHandle(request, response, this.handler, mv);
                }
        }
}

3.6.3 triggerAfterCompletion(processedRequest, response, mappedHandler, ex);

调用拦截器结束方法(视图呈现之后)。

// org.springframework.web.servlet.DispatcherServlet#triggerAfterCompletion
void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable 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);
                        }
                }
        }
}

3.7 ha.handle(processedRequest, response, mappedHandler.getHandler());

这里是真正调用 Handler 处理业务逻辑的地方。我们这里看的是 RequestMappingHandlerAdapterha.handle(processedRequest, response, mappedHandler.getHandler()); 方法会调用 RequestMappingHandlerAdapter#invokeHandlerMethod 方法。同时在这个方法里面,会通过反射的方式调用 HandlerMthoder。并将返回结果封装成 ModelAndView

@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
      HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

   // 装饰器模式,把原生的request, response 封装到一个对象中 方便后续只用这一个参数就可以
   ServletWebRequest webRequest = new ServletWebRequest(request, response);
   try {
      // 数据绑定器
      WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
      // 获取到模型工厂 Model(要交给页面的数据)  View(我们要去的视图)
      ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
      // 将 handlerMethod 转换成 ServletInvocableHandlerMethod
      ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
      // 设置ServletInvocableHandlerMethod  的一些属性
      // todo 参数解析器
      if (this.argumentResolvers != null) {
         invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
      }
      // todo 返回值解析器
      if (this.returnValueHandlers != null) {
         invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
      }
      invocableMethod.setDataBinderFactory(binderFactory);
      invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

      // 模型和视图的容器,以后流程共享ModelAndView数据的临时存储器
      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();
         LogFormatUtils.traceDebug(logger, traceOn -> {
            String formatted = LogFormatUtils.formatValue(result, !traceOn);
            return "Resume with async result [" + formatted + "]";
         });
         invocableMethod = invocableMethod.wrapConcurrentResult(result);
      }

      // todo 开始执行目标方法,反射调用HandlerMethod
      invocableMethod.invokeAndHandle(webRequest, mavContainer);
      if (asyncManager.isConcurrentHandlingStarted()) {
         return null;
      }

      // todo 封装ModelAndView
      return getModelAndView(mavContainer, modelFactory, webRequest);
   }
   finally {
      webRequest.requestCompleted();
   }

我们首先来看下 核心方法invocableMethod.invokeAndHandle(webRequest, mavContainer);

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
      Object... providedArgs) throws Exception {

   // todo 目标方法的反射执行
   Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
   setResponseStatus(webRequest);

   if (returnValue == null) {
      if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
         disableContentCachingIfNecessary(webRequest);
         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 {
      // todo 返回值的处理
      this.returnValueHandlers.handleReturnValue(
            returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
   }
   catch (Exception ex) {
      if (logger.isTraceEnabled()) {
         logger.trace(formatErrorForReturnValue(returnValue), ex);
      }
      throw ex;
   }
}

3.7.1 请求参数解析器argumentResolvers

核心方法invokeForRequest中,

@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
      Object... providedArgs) throws Exception {

   // todo 获取方法的  请求参数
   Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
   if (logger.isTraceEnabled()) {
      logger.trace("Arguments: " + Arrays.toString(args));
   }
   // 反射执行
   return doInvoke(args);
}

protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
      Object... providedArgs) throws Exception {

   // 拿到方法的所有参数
   MethodParameter[] parameters = getMethodParameters();
   if (ObjectUtils.isEmpty(parameters)) {
      return EMPTY_ARGS;
   }

   // 准备args的数组,跟方法的参数长度一样,挨个确定每个参数都是什么值
   Object[] args = new Object[parameters.length];
   for (int i = 0; i < parameters.length; i++) {
      MethodParameter parameter = parameters[i];
      parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
      // 先去已提供的参数里面查找
      args[i] = findProvidedArgument(parameter, providedArgs);
      if (args[i] != null) {
         continue;
      }
      // todo 解析参数
      if (!this.resolvers.supportsParameter(parameter)) {
         throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
      }
      try {
         args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
      }
      catch (Exception ex) {
         // Leave stack trace for later, exception may actually be resolved and handled...
         if (logger.isDebugEnabled()) {
            String exMsg = ex.getMessage();
            if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
               logger.debug(formatArgumentError(parameter, exMsg));
            }
         }
         throw ex;
      }
   }
   return args;
}

private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
   // 先看缓存中有没有
   HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
   if (result == null) {
      // 27个参数解析器 遍历执行
      for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
         //
         if (resolver.supportsParameter(parameter)) {
            result = resolver;
            // 支持这种参数的解析器也会被放到缓存中argumentResolverCache
            this.argumentResolverCache.put(parameter, result);
            break;
         }
      }
   }
   return result;
}

一共有27种请求参数解析器,针对不同的参数进行使用不同的解析器。

image.png

执行目标方法就是通过反射执行的。

3.7.2 返回值参数解析器

this.returnValueHandlers.handleReturnValue(
      returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
      ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

   // todo 找到合适的返回值处理器
   HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
   if (handler == null) {
      throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
   }
   // 处理返回值
   handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}

@Nullable
private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) {
   boolean isAsyncValue = isAsyncReturnValue(value, returnType);
   for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
      if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
         continue;
      }
      if (handler.supportsReturnType(returnType)) {
         return handler;
      }
   }
   return null;
}

一共有15种返回值解析器。 image.png

有一个RequestResponseBodyMethodProcessor,只要你标注了@ResponseBody注解,使用这个处理器进行处理,将返回值数据直接返回。

3.7.3 封装ModelAndView

getModelAndView(mavContainer, modelFactory, webRequest);

@Nullable
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
      ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {

   // modelFactory 准备模型数据,请求域数据共享,session里面的数据存储到请求域中
   modelFactory.updateModel(webRequest, mavContainer);
   if (mavContainer.isRequestHandled()) {
      return null;
   }
   ModelMap model = mavContainer.getModel();
   ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
   if (!mavContainer.isViewReference()) {
      mav.setView((View) mavContainer.getView());
   }
   if (model instanceof RedirectAttributes) {
      Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
      HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
      if (request != null) {
         // todo 重定向数据的共享 RedictView ,先把数据转移到request,再把request转移到session中
         RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
      }
   }
   return mav;
}

3.8 applyDefaultViewName(processedRequest, mv);

当 控制层的返回结果是 null 或者 void 时,则表明没有找到对应视图,Spring 会根据request 信息来进行解析,查找默认的视图。

private void applyDefaultViewName(HttpServletRequest request, @Nullable ModelAndView mv) throws Exception {
        // 视图转换器应用于添加前后缀的情况
        if (mv != null && !mv.hasView()) {
                String defaultViewName = getDefaultViewName(request);
                if (defaultViewName != null) {
                        mv.setViewName(defaultViewName);
                }
        }
}

3.9 processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

这一步的作用是集中处理请求异常并解析最终的ModelAndView,根据解析出来的视图跳转页面

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
      @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
      @Nullable Exception exception) throws Exception {

   boolean errorView = false;

   // 判断上面的过程是否出现了异常。如果本次请求出现了异常,并不能因此终止程序。所以需要解析出来异常,返回对应的视图结果,告知用户出现了异常。
   // 有异常的处理
   if (exception != null) {
      // 根据不同的异常类型解析返回不同的视图告知用户
      if (exception instanceof ModelAndViewDefiningException) {
         logger.debug("ModelAndViewDefiningException encountered", exception);
         mv = ((ModelAndViewDefiningException) exception).getModelAndView();
      }
      else {
         // 定义无数种异常解析器就会得到不同的异常解析效果
         Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
         // todo 处理异常的情况
         // 如果所有异常都不能处理,这个异常就直接抛出去
         mv = processHandlerException(request, response, handler, exception);
         errorView = (mv != null);
      }
   }

   // 上面所有的异常解析器都没能处理这个异常,就不执行下面的逻辑了。。
   // Did the handler return a view to render?
   // 动态策略
   // @ResponseBody(提前在解析返回值的时候,就已经把数据写出去了)
   // 如果在Handler实例的处理过程中返回了 view,则需要做页面处理
   if (mv != null && !mv.wasCleared()) {
      // todo 渲染,来解析模型和视图
      render(mv, request, response);
      if (errorView) {
         WebUtils.clearErrorRequestAttributes(request);
      }
   }
   else {
      if (logger.isTraceEnabled()) {
         logger.trace("No view rendering, null ModelAndView returned.");
      }
   }

   if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
      // Concurrent handling started during a forward
      return;
   }

   if (mappedHandler != null) {
      // Exception (if any) is already handled..
      // 触发 拦截器完成事件
      mappedHandler.triggerAfterCompletion(request, response, null);
   }
}

3.9.1 render(mv, request, response);

在最后的处理中,一定会涉及页面的跳转问题。而在render(mv, request, response); 完成了页面的跳转。

// org.springframework.web.servlet.DispatcherServlet#render
protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
        // Determine locale for request and apply it to the response.
        Locale locale =
                        (this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
        response.setLocale(locale);

        View view;
        String viewName = mv.getViewName();
        // 如果viewname不为null,则需要通过viewName 解析出来对应的 View
        if (viewName != null) {
                // We need to resolve the view name.
                // 解析视图名称
                view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
                if (view == null) {
                        throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
                                        "' in servlet with name '" + getServletName() + "'");
                }
        }
        else {
                // 如果viewName 为null,则认为 ModelAndView 直接指定了View。不需要解析了。
                // No need to lookup: the ModelAndView object contains the actual View object.
                view = mv.getView();
                if (view == null) {
                        throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
                                        "View object in servlet with name '" + getServletName() + "'");
                }
        }

        // Delegate to the View object for rendering.
        if (logger.isTraceEnabled()) {
                logger.trace("Rendering view [" + view + "] ");
        }
        try {
                // 设置视图状态。可能是 404, 500 等情况
                if (mv.getStatus() != null) {
                        response.setStatus(mv.getStatus().value());
                }
                // 进行跳转逻辑
                view.render(mv.getModelInternal(), request, response);
        }
        catch (Exception ex) {
                if (logger.isDebugEnabled()) {
                        logger.debug("Error rendering view [" + view + "]", ex);
                }
                throw ex;
        }
}

resolveViewName(viewName, mv.getModelInternal(), locale, request);通过视图解析器进行视图解析。返回合适视图。具体实现如下。

// org.springframework.web.servlet.DispatcherServlet#resolveViewName
@Nullable
protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
            Locale locale, HttpServletRequest request) throws Exception {

    if (this.viewResolvers != null) {
            // 遍历视图解析器,直到有解析器能解析出来视图
            for (ViewResolver viewResolver : this.viewResolvers) {
                    View view = viewResolver.resolveViewName(viewName, locale);
                    if (view != null) {
                            return view;
                    }
            }
    }
    return null;
}

我们看一下 viewResolver.resolveViewName(viewName, locale) 方法。这里我们看InternalResourceViewResolver#resolveViewName 方法,其方法是在父类AbstractCachingViewResolver#resolveViewName中实现,如下:

@Override
@Nullable
public View resolveViewName(String viewName, Locale locale) throws Exception {
        // 如果没有缓存,则直接创建 View
        if (!isCache()) {
                return createView(viewName, locale);
        }
        else {
                // 从缓存中获取视图
                Object cacheKey = getCacheKey(viewName, locale);
                View view = this.viewAccessCache.get(cacheKey);
                if (view == null) {
                        synchronized (this.viewCreationCache) {
                                view = this.viewCreationCache.get(cacheKey);
                                if (view == null) {
                                        // Ask the subclass to create the View object.
                                        view = createView(viewName, locale);
                                        if (view == null && this.cacheUnresolved) {
                                                view = UNRESOLVED_VIEW;
                                        }
                                        if (view != null && this.cacheFilter.filter(view, viewName, locale)) {
                                                this.viewAccessCache.put(cacheKey, view);
                                                this.viewCreationCache.put(cacheKey, view);
                                        }
                                }
                        }
                }
                else {
                        if (logger.isTraceEnabled()) {
                                logger.trace(formatKey(cacheKey) + "served from cache");
                        }
                }
                return (view != UNRESOLVED_VIEW ? view : null);
        }
}

createView 方法 被 UrlBasedViewResolver 重写了。UrlBasedViewResolver#createView具体如下:

@Override
protected View createView(String viewName, Locale locale) throws Exception {
        // If this resolver is not supposed to handle the given view,
        // return null to pass on to the next resolver in the chain.
        // 如果当前视图解析器无法解析该视图,则返回null
        if (!canHandle(viewName, locale)) {
                return null;
        }

        // Check for special "redirect:" prefix.
        // 处理前缀为  "redirect:" (重定向)的情况
        if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
                String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
                RedirectView view = new RedirectView(redirectUrl,
                                isRedirectContextRelative(), isRedirectHttp10Compatible());
                String[] hosts = getRedirectHosts();
                if (hosts != null) {
                        view.setHosts(hosts);
                }
                return applyLifecycleMethods(REDIRECT_URL_PREFIX, view);
        }

        // Check for special "forward:" (请求转发)prefix.
        // 处理前缀为  "forward:" 的情况
        if (viewName.startsWith(FORWARD_URL_PREFIX)) {
                String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
                InternalResourceView view = new InternalResourceView(forwardUrl);
                return applyLifecycleMethods(FORWARD_URL_PREFIX, view);
        }

        // Else fall back to superclass implementation: calling loadView.
        // 调用父类的方法创建视图
        return super.createView(viewName, locale);
}

super.createView(viewName, locale); 调用 AbstractCachingViewResolver#createView 如下:

// org.springframework.web.servlet.view.AbstractCachingViewResolver#createView
protected View createView(String viewName, Locale locale) throws Exception {
        return loadView(viewName, locale);
}

// org.springframework.web.servlet.view.UrlBasedViewResolver#loadView
@Override
protected View loadView(String viewName, Locale locale) throws Exception {
        AbstractUrlBasedView view = buildView(viewName);
        View result = applyLifecycleMethods(viewName, view);
        return (view.checkResource(locale) ? result : null);
}

// org.springframework.web.servlet.view.UrlBasedViewResolver#buildView
protected AbstractUrlBasedView buildView(String viewName) throws Exception {
        Class<?> viewClass = getViewClass();
        Assert.state(viewClass != null, "No view class");

        AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(viewClass);
        // 设置视图 url 添加前缀和后缀
        view.setUrl(getPrefix() + viewName + getSuffix());
        view.setAttributesMap(getAttributesMap());

        String contentType = getContentType();
        if (contentType != null) {
                view.setContentType(contentType);
        }

        String requestContextAttribute = getRequestContextAttribute();
        if (requestContextAttribute != null) {
                view.setRequestContextAttribute(requestContextAttribute);
        }

        Boolean exposePathVariables = getExposePathVariables();
        if (exposePathVariables != null) {
                view.setExposePathVariables(exposePathVariables);
        }
        Boolean exposeContextBeansAsAttributes = getExposeContextBeansAsAttributes();
        if (exposeContextBeansAsAttributes != null) {
                view.setExposeContextBeansAsAttributes(exposeContextBeansAsAttributes);
        }
        String[] exposedContextBeanNames = getExposedContextBeanNames();
        if (exposedContextBeanNames != null) {
                view.setExposedContextBeanNames(exposedContextBeanNames);
        }

        return view;
}

org.springframework.web.servlet.view.AbstractView#render 中完成了视图跳转。 对于ModelView 的使用,我们可以将一些属性放入其中,然后在页面上通过 JSTL 语法或者 request 获取属性,这个功能的实现就是在这里完成的。实现原理很简单,就是将要用到的属性方法request中,以便在其他地方可以获取到。

@Override
public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
                HttpServletResponse response) throws Exception {

        if (logger.isDebugEnabled()) {
                logger.debug("View " + formatViewName() +
                                ", model " + (model != null ? model : Collections.emptyMap()) +
                                (this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
        }
        // 将要用到的属性放入到mergedModel  中
        Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
        // 准备 Response
        prepareResponse(request, response);
        // 处理页面跳转。同时将 mergedModel  保存到request中
        renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
}

我们看一下InternalResourceView#renderMergedOutputModel方法:

@Override // 真真的渲染逻辑
protected void renderMergedOutputModel(
      Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

   // Expose the model object as request attributes.
   // todo 暴露model的数据作为请求域 中的数据
   exposeModelAsRequestAttributes(model, request);

   // Expose helpers as request attributes, if any.
   exposeHelpers(request);

   // Determine the path for the request dispatcher.
   String dispatcherPath = prepareForRendering(request, response);

   // Obtain a RequestDispatcher for the target resource (typically a JSP).
   RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
   if (rd == null) {
      throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
            "]: Check that the corresponding file exists within your web application archive!");
   }

   // If already included or response already committed, perform include, else forward.
   if (useInclude(request, response)) {
      response.setContentType(getContentType());
      if (logger.isDebugEnabled()) {
         logger.debug("Including [" + getUrl() + "]");
      }
      rd.include(request, response);
   }

   else {
      // Note: The forwarded resource is supposed to determine the content type itself.
      if (logger.isDebugEnabled()) {
         logger.debug("Forwarding to [" + getUrl() + "]");
      }
      // todo 转发
      rd.forward(request, response);
   }
}

参考文章

Spring5源码注释github地址
Spring源码深度解析(第2版)
spring源码解析
Spring源码深度解析笔记
Spring注解与源码分析
Spring注解驱动开发B站教程