SpringMVC系列第16篇：源码解析SpringMVC处理请求的流程

star2017 1年前 ⋅ 344 阅读

大家好，我是路人，这是SpringMVC系列第16篇。

本文将通过阅读源码的方式带大家了解springmvc处理请求的完整流程，干货满满。

目录

1、先了解下SpringMVC常用的10组件

1.1、DispatcherServlet：前端控制器

这个大家是最熟悉的，是一个servlet，是springmvc处理请求的入口，不需要咱们开发，由框架提供。

作用：统一处理请求和响应，整个流程控制的中心，由它来调用其他组件处理用户的请求。

1.2、HandlerMapping：处理器映射器

作用：根据请求的信息（如url、method、header等）查找请求处理器，即找到自定义的controller中处理请求的方法。

HandlerMapping接口源码如下，getHandler：根据请求查找请求处理器，会返回一个HandlerExecutionChain对象。

  1. public interface HandlerMapping {
  2.     HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
  3. }

常见的实现类：

  • RequestMappingHandlerMapping：请求映射处理器映射，用来处理@RequestMapping定义的处理器的

1.3、HandlerExecutionChain：处理器执行链

HandlerMapping#getHandler方法会根据请求得到一个HandlerExecutionChain对象。

HandlerExecutionChain源码如下，主要包含了3个信息

  • handler：请求处理器，通常就是我们自定义的controller对象及方法
  • interceptorList：拦截器，当前请求匹配到的拦截器列表
  • interceptorIndex：拦截器索引，用来记录执行到第几个拦截器了
  1. public class HandlerExecutionChain {
  3.     private final Object handler;
  5.     private final List<HandlerInterceptor> interceptorList = new ArrayList<>();
  7.     private int interceptorIndex = -1;
  9. }

1.4、handler：处理器

通常需要我们自己开发，一般指我们自定义的controller，在DispatcherServlet的控制下handler对具体的请求进行处理。

1.5、HandlerAdapter：处理器适配器

他负责对handler的方法进行调用，由于handler的类型可能有很多种，每种handler的调用过程可能不一样，此时就需要用到适配器HandlerAdapte，适配器对外暴露了统一的调用方式（见其handle方法），内部将handler的调用过程屏蔽了，HandlerAdapter接口源码如下，主要有2个方法需要注意：

  • supports：当前HandlerAdapter是否支持handler，其内部主要就是判HandlerAdapter是否能够处理handler的调用
  • handle：其内部负责调用handler的来处理用户的请求，返回返回一个ModelAndView对象
  1. public interface HandlerAdapter {
  3.     boolean supports(Object handler);
  5.     @Nullable
  6.     ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
  8. }

常见的实现类：

  • RequestMappingHandlerAdapter：其内部用来调用@RequestMapping标注的方法

1.6、ModelAndView：模型和视图

这个对象中主要用来存放视图的名称和共享给客户端的数据。

  1. public class ModelAndView {
  3.     /*视图*/
  4.     @Nullable
  5.     private Object view;
  7.     /*模型，用来存放共享给客户端的数据*/
  8.     @Nullable
  9.     private ModelMap model;
  11. }

1.7、ViewResolver：视图解析器

这个是框架提供的，不需要咱们自己开发，它负责视图解析，根据视图的名称得到对应的视图对象（View）。

ViewResolver接口源码

  1. public interface ViewResolver {
  3.     @Nullable
  4.     View resolveViewName(String viewName, Locale locale) throws Exception;
  6. }

这个接口有很多实现类，比如jsp的、freemarker、thymeleaf的等，他们都有各自对应的ViewResolver。

而比较常的实现类是InternalResourceViewResolver，这个大家应该比较熟悉吧，目前为止我们前面的文章用到的都是这个视图解析器，用来处理jsp格式的视图页面，带大家再回顾一下这个类的配置，如下

  1. <!-- 添加视图解析器 -->
  2. <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  3.     <property name="prefix" value="/WEB-INF/view/"/>
  4.     <property name="suffix" value=".jsp"/>
  5. </bean>

InternalResourceViewResolver比较重要，这里说下这个类的resolveViewName方法获取视图的过程，大家也可以去阅读InternalResourceViewResolver#resolveViewName方法获得，大致的过程如下：

step1：判断视图viewName是否以redirect:开头，如果是，则返回RedirectView类型的视图对象，RedirectView是用来重定向的，RedirectView内部用到的是response.sendRedirect(url)进行页面重定向；否则继续向下step2

step2：判断viewName是否以forward:开头，如果是，则返回InternalResourceView类型的视图对象，InternalResourceView是用来做跳转的，InternalResourceView内部用到的是request.getRequestDispatcher(path).forward(request, response)进行页面跳转；否则继续向下step3

step3：判断当前项目是否存在jstl所需的类，如果是，则返回JstlView类型的视图，否则返回InternalResourceView类型的视图，这两个视图的render方法最终会通过request.getRequestDispatcher(path).forward(request, response)进行页面的跳转，跳转的路径是：InternalResourceViewResolver的前缀prefix + viewName+InternalResourceViewResolver的后缀prefix

1.8、View：视图

负责将结果展示给用户，View接口源码如下，render方法根据指定的模型数据（model）渲染视图，即render方法负责将结果输出给客户端。

  1. public interface View {
  2.     void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
  3.             throws Exception;
  4. }

View接口常见的2个实现类

  • RedirectView：负责重定向的，内部通过response.sendRedirect(url)进行页面重定向
  • InternalResourceViewResolver：负责页面跳转的，内部通过request.getRequestDispatcher(path).forward(request, response)进行页面的跳转

1.9、HandlerExceptionResolver：处理器异常解析器

负责处理异常的，HandlerExceptionResolver接口有个resolveException方法，用来解析异常，返回异常情况下对应的ModelAndView对象

  1. public interface HandlerExceptionResolver {
  3.     @Nullable
  4.     ModelAndView resolveException(
  5.             HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
  7. }

1.10、HttpMessageConverter：http报文转换器

将请求报文转换为Java对象，或将Java对象转换为响应报文，在处理@RequestBody、RequestEntity、@ResponseBody、ResponseEntity的时候会用到

  1. public interface HttpMessageConverter<T> {
  3.     /**
  4.      * 是否可以将请求保温读取给方法参数指定的类型
  5.      */
  6.     boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
  8.     /**
  9.      * 是否可以将响应的保温转换为方法参数指定的类型输出
  10.      */
  11.     boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);
  13.     /**
  14.      * 当前转换器支持的类型
  15.      */
  16.     List<MediaType> getSupportedMediaTypes();
  18.     /**
  19.      * 当前转换器支持的类型
  20.      */
  21.     default List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
  22.         return (canRead(clazz, null) || canWrite(clazz, null) ?
  23.                 getSupportedMediaTypes() : Collections.emptyList());
  24.     }
  26.     /**
  27.      * 将http保温转换为给定的类型，然后返回
  28.      */
  29.     T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
  30.             throws IOException, HttpMessageNotReadableException;
  32.     /**
  33.      * 将给定的对象t，转换为http报文输出到客户端
  34.      */
  35.     void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
  36.             throws IOException, HttpMessageNotWritableException;
  38. }

2、处理流程：源码解析

2.1、请求到达入口：doDispatch

springmvc的所有请求，最终都会到达org.springframework.web.servlet.DispatcherServlet#doDispatch这个方法，整个请求的大致处理过程都在这个方法中，咱们从这个方法开始分析，源码如下，大家注意代码中的注释，带有标号，比如①、②、③这样需要的注释，大家需要注意了，这些是关键的步骤，稍后会对这些步骤做详细的说明

  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.     //请求对象
  3.     HttpServletRequest processedRequest = request;
  4.     //处理器执行链对象
  5.     HandlerExecutionChain mappedHandler = null;
  6.     boolean multipartRequestParsed = false;
  8.     //获取异步处理管理器，servlet3.0后支持异步处理，可以在子线程中响应用户请求
  9.     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  11.     try {
  12.         //模型和视图
  13.         ModelAndView mv = null;
  14.         //异常对象
  15.         Exception dispatchException = null;
  17.         try {
  18.             //①：解析multipart类型的请求，上传文件用的就是multipart类型的请求方式
  19.             processedRequest = checkMultipart(request);
  20.             //用来标记是否是multipart类型的请求
  21.             multipartRequestParsed = (processedRequest != request);
  23.             //②：根据请求获取HandlerExecutionChain对象
  24.             mappedHandler = getHandler(processedRequest);
  25.             //如果没有找到处理器，就404了
  26.             if (mappedHandler == null) {
  27.                 noHandlerFound(processedRequest, response);
  28.                 return;
  29.             }
  31.             //③：根据处理器获取HandlerAdapter
  32.             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  34.             //④：调用拦截器的preHandle方法，若返回false，处理结束
  35.             if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  36.                 return;
  37.             }
  39.             //⑤：调用handler实际处理请求，获取ModelAndView对象，这里会调用HandlerAdapter#handle方法处理请求，其内部会调用handler来处理具体的请求
  40.             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  42.             //判断异步请求不是已经开始了，开始了就返回了
  43.             if (asyncManager.isConcurrentHandlingStarted()) {
  44.                 return;
  45.             }
  46.             //如果mv对象中没有视图 & DispatcherServlet配置了默认的视图，则给mv安排一个默认的视图
  47.             applyDefaultViewName(processedRequest, mv);
  49.             //⑥：调用拦截器的postHandle方法
  50.             mappedHandler.applyPostHandle(processedRequest, response, mv);
  51.         }
  52.         catch (Exception ex) {
  53.             dispatchException = ex;
  54.         }
  55.         catch (Throwable err) {
  56.             dispatchException = new NestedServletException("Handler dispatch failed", err);
  57.         }
  58.         //⑦：处理分发结果，渲染视图(包含了正常处理和异常情况的处理)，将结果输出到客户端
  59.         processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  60.     }
  61.     catch (Exception ex) {
  62.         //⑧：调用拦截器的afterCompletion方法
  63.         triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
  64.     }
  65.     catch (Throwable err) {
  66.         //⑧：调用拦截器的afterCompletion方法
  67.         triggerAfterCompletion(processedRequest, response, mappedHandler,
  68.                 new NestedServletException("Handler processing failed", err));
  69.     }
  70.     finally {
  71.         //对于异步处理的情况，调用异步处理的拦截器AsyncHandlerInterceptor的afterConcurrentHandlingStarted方法
  72.         if (asyncManager.isConcurrentHandlingStarted()) {
  73.             if (mappedHandler != null) {
  74.                 mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
  75.             }
  76.         }
  77.         else {
  78.             //对于multipart的请求，清理资源，比如文件上传的请求，在上传的过程中文件会被保存到临时文件中，这里就会对这些文件继续清理
  79.             if (multipartRequestParsed) {
  80.                 cleanupMultipart(processedRequest);
  81.             }
  82.         }
  83.     }
  84. }

下面我们来对上面带有编号的步骤进行分析。

2.2、①：解析multipart类型的请求

  1. //①：解析multipart类型的请求，上传文件用的就是multipart类型的请求方式
  2. processedRequest = checkMultipart(request);

checkMultipart(request)源码

  1. protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
  2.     //判断multipartResolver解析器是否存在 && 请求是否是multipart类型
  3.     if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
  4.         //将请求转换为multipart类型的请求对象，通常为MultipartHttpServletRequest类型
  5.         return this.multipartResolver.resolveMultipart(request);
  6.     }
  7.     return request;
  8. }

2.3、②：根据请求获取HandlerExecutionChain对象

  1. //②：根据请求获取HandlerExecutionChain对象
  2. mappedHandler = getHandler(processedRequest);

getHandler(processedRequest)源码如下，遍历所有的处理器映射器HandlerMapping，调用他们的getHandler方法得到能够处理当前请求的HandlerExecutionChain对象，这个对象中包含了3个信息

  • handler：请求处理器，通常就是我们自定义的controller对象及方法
  • interceptorList：拦截器，当前请求匹配到的拦截器列表
  • interceptorIndex：拦截器索引，用来记录执行到第几个拦截器了
  1. protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  2.     if (this.handlerMappings != null) {
  3.         for (HandlerMapping mapping : this.handlerMappings) {
  4.             HandlerExecutionChain handler = mapping.getHandler(request);
  5.             if (handler != null) {
  6.                 return handler;
  7.             }
  8.         }
  9.     }
  10.     return null;
  11. }

有兴趣的可以去看一下RequestMappingHandlerMapping这个类的源码，也是最常用的一个HandlerMapping，它会根据@RequestMapping来找到能够处当前请求的处理器，RequestMappingHandlerMapping#getHandler方法查找得到的HandlerExecutionChain对象中的handler类型为HandlerMethod，代码在下面这个位置

  1. org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#getHandlerInternal

HandlerMethod对象中包含了能够处理请求的bean及方法信息

2.4、③：根据处理器获取HandlerAdapter

  1. //③：根据处理器获取HandlerAdapter
  2. HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

getHandlerAdapter方法源码，遍历HandlerAdapter列表，找到能够处理当前handler的HandlerAdapter，如果没找到会报错

  1. protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
  2.     if (this.handlerAdapters != null) {
  3.         for (HandlerAdapter adapter : this.handlerAdapters) {
  4.             if (adapter.supports(handler)) {
  5.                 return adapter;
  6.             }
  7.         }
  8.     }
  10.     throw new ServletException("No adapter for handler [" + handler +
  11.                                "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
  12. }

此方法通常返回的是RequestMappingHandlerAdapter类型的对象，RequestMappingHandlerAdapter这个类会根据HandlerMethod提供的信息，通过反射调用@RequestMapping标注的方法。

2.5、④：调用拦截器的preHandle方法

  1. //④：调用拦截器的preHandle方法，若返回false，处理结束
  2. if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  3.     return;
  4. }

mappedHandler.applyPreHandle源码如下，主要干了3个事情

  • 循环调用拦截器的preHandle方法
  • 如果某个拦截器的preHandle方法返回false，则反向依次调用那些preHandle方法返回ture的拦截器的afterCompletion方法；这句话有点绕，比如有3个拦截器，1、2的preHandler返回了true，而3返回的是false，那么这里将按照2、1的顺序调用他们的afterCompletion方法
  • 记录拦截器的执行位置
  1. boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.     for (int i = 0; i < this.interceptorList.size(); i++) {
  3.         HandlerInterceptor interceptor = this.interceptorList.get(i);
  4.         //调用拦截器的preHandle方法
  5.         if (!interceptor.preHandle(request, response, this.handler)) {
  6.             //如果拦截器返回false，则反向依次调用那些preHandle方法返回ture的拦截器的afterCompletion方法
  7.             triggerAfterCompletion(request, response, null);
  8.             return false;
  9.         }
  10.         //记录当前拦截器执行的位置
  11.         this.interceptorIndex = i;
  12.     }
  13.     return true;
  14. }

triggerAfterCompletion方法源码如下，通过拦截器当前执行的位置interceptorIndex逆向调用拦截器的afterCompletion方法

  1. void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
  2.     for (int i = this.interceptorIndex; i >= 0; i--) {
  3.         HandlerInterceptor interceptor = this.interceptorList.get(i);
  4.         try {
  5.             interceptor.afterCompletion(request, response, this.handler, ex);
  6.         }
  7.         catch (Throwable ex2) {
  8.             logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
  9.         }
  10.     }
  11. }

2.6、⑤：调用handler实际处理请求，获取ModelAndView对象

2.6.1、过程

  1. //⑤：调用handler实际处理请求，获取ModelAndView对象，这里会调用HandlerAdapter#handle方法处理请求，其内部会调用handler来处理具体的请求
  2. mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

ha.handler方法内部通通过程会走到RequestMappingHandlerAdapter#invokeHandlerMethod方法，这个方法内部会通过反射调用@RequestMapping标注的方法，这个方法内部代码比较复杂，咱们就不进去了，这里说一下这个方法主要做了3个非常重要的事情：

  • step1：组装目标方法需要的参数
  • step2：通过反射调用处理请求的目标方法，获取方法的返回值
  • step3：对方法的返回值进行处理

下面来细说一下这3个步骤，这些地方有好东西，大家集中注意力了。

2.6.2、step1：组装目标方法需要的参数：HandlerMethodArgumentResolver

处理器的方法需要的参数有各种类型的，所以组装这些参数是比较关键的地方，组装参数的源码位于下面这个位置

  1. org.springframework.web.method.support.InvocableHandlerMethod#getMethodArgumentValues

获取方法需要的参数值，会用到HandlerMethodArgumentResolver这个对象，叫做：处理器方法参数解析器，用来解析请求，得到方法需要的参数，大家看一下这个接口，源码如下，主要有2个方法

  • supportsParameter：是否能够解析parameter指定的参数
  • resolveArgument：通过请求和parameter参数解析得到参数的值
  1. public interface HandlerMethodArgumentResolver {
  3.     //判断当前解析器是否能处理这个parameter这个参数，也就是说是否能够将请求中的数据转换为parameter指定的参数的值
  4.     boolean supportsParameter(MethodParameter parameter);
  6.     //解析参数：从http请求中解析出控制器需要的参数的值
  7.     Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
  8.             NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
  10. }

这个接口有很多实现类，列几个比较熟悉的，当大家想知道springmvc可以接收哪些类型的参数，以及这些参数有什么特点的时候，可以去看看这些类的源码，你会秒懂的

实现类 对应的控制器参数 说明
PathVariableMapMethodArgumentResolver @PathVariable 标注参数 从url中提取参数的值
RequestHeaderMethodArgumentResolver @RequestHeader标注参数 从http头中提取参数值
RequestParamMethodArgumentResolver @RequestParam标注参数 http请求参数中获取值
RequestResponseBodyMethodProcessor @RequestBody标注参数 提取body数据，转换为参数类型
ServletResponseMethodArgumentResolver ServletResponse、OutputStream、Writer这3种类型的参数 这几种类型用来控制http请求的响应输出流
HttpEntityMethodProcessorHttpEntity HttpEntity类型的参数 HttpEntity中包含了http请求头和body的所有信息
ExpressionValueMethodArgumentResolver @Value标注的参数 spel表达式，从spring容器中获取值
MapMethodProcessor 参数为Map或者子类型 -
ModelMethodProcessor 参数为org.springframework.ui.Model 或子类型 -
ModelAttributeMethodProcessor @ModelAttribute标注的参数 -

2.6.3、step2：通过反射调用目标方法

也就是调用controller中的@RequestMapping标注的方法，代码位置

  1. org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle

对应的源码如下，这个方法springmvc框架中主要有2个地方会调用

  • 第1个地方是：调用处理请求的实际方法的时候
  • 第2个地方是：方法有异常的时候，异常解析器里面也会用到这个方法，稍后后面会讲
  1. public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
  2.                             Object... providedArgs) throws Exception {
  3.     //1.通过反射调用目标方法，内部会组装目标方法需要的参数
  4.     Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
  6.     //如果返回值为空，表示目标方法中已经完成了请求的所有处理，表示请求处理结束了，将执行mavContainer.setRequestHandled(true)标记请求处理完毕
  7.     if (returnValue == null) {
  8.         if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
  9.             mavContainer.setRequestHandled(true);
  10.             return;
  11.         }
  12.     }
  13.     //若getResponseStatusReason()不为空，表示请求已经处理过了
  14.     else if (StringUtils.hasText(getResponseStatusReason())) {
  15.         mavContainer.setRequestHandled(true);
  16.         return;
  17.     }
  18.     //走到这里，说明有返回值，标记请求未处理完毕
  19.     mavContainer.setRequestHandled(false);
  20.     //对返回值进行处理
  21.     this.returnValueHandlers.handleReturnValue(
  22.             returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
  23. }

2.6.4、step3：处理方法返回值：HandlerMethodReturnValueHandler

大家注意，上面代码中这部分代码，如下，会对反射调用的结果returnValue进行处理

  1. //对返回值进行处理
  2. this.returnValueHandlers.handleReturnValue(
  3.     returnValue, getReturnValueType(returnValue), mavContainer, webRequest);

进入handleReturnValue方法内部去看一下，最终代码在下面这个位置

  1. org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite#handleReturnValue

这个方法的源码如下

  1. public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
  2.                               ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
  3.     //根据返回值找到HandlerMethodReturnValueHandler
  4.     HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
  5.     if (handler == null) {
  6.         throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
  7.     }
  8.     //调用HandlerMethodReturnValueHandler#handleReturnValue处理返回值
  9.     handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
  10. }
  12. @Nullable
  13. private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) {
  14.     //根据返回值判断是否是异步请求
  15.     boolean isAsyncValue = isAsyncReturnValue(value, returnType);
  16.     for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
  17.         if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
  18.             continue;
  19.         }
  20.         if (handler.supportsReturnType(returnType)) {
  21.             return handler;
  22.         }
  23.     }
  24.     return null;
  25. }

这里关键的信息要看HandlerMethodReturnValueHandler接口，这个接口用来处理返回值，看一下其源码，包含2个方法

  • supportsReturnType：是否能够处理returnType参数指定的返回值
  • handleReturnValue：处理返回值
  1. public interface HandlerMethodReturnValueHandler {
  3.     boolean supportsReturnType(MethodParameter returnType);
  5.     void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
  6.             ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception;
  8. }

此接口有很多实现类，如下图，图下的表格中会列出常见的一些及说明，建议大家抽空，都点开看看其源码

实现类 说明
ViewNameMethodReturnValueHandler 返回值为视图名称时的解析器
MapMethodProcessor 返回值为Map的解析器
StreamingResponseBodyReturnValueHandler 返回值为ResponseEntity类型时的解析器
DeferredResultMethodReturnValueHandler 返回值为DeferredResult类型时的解析器，表示异步请求
CallableMethodReturnValueHandler 返回值为Callable类型时的解析器，表示异步请求
ModelMethodProcessor 返回值为Model类型时的解析器
ModelAndViewMethodReturnValueHandler 返回值为ModelAndView类型时的解析器
RequestResponseBodyMethodProcessor 方法上标注有@ResponseBody注解时返回值的解析器
HttpEntityMethodProcessor 返回值为HttpEntity类型但是非RequestEntity类型时的解析器

这里找一个比较有代表性的，带大家看一下，就以RequestResponseBodyMethodProcessor来说一下，这个会处理@RequestBody标注的方法，抽取其2个关键方法的代码，如下

  1. //判断类上或者目标方法上是否有@ResponseBody注解
  2. @Override
  3. public boolean supportsReturnType(MethodParameter returnType) {
  4.     return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) ||
  5.             returnType.hasMethodAnnotation(ResponseBody.class));
  6. }
  8. //处理返回值
  9. @Override
  10. public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
  11.                               ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
  12.         throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
  13.     //1：标注为请求已处理，因为当前handleReturnValue方法会直接将结果输出到客户端，所以后续就不需要再进行视图渲染了，表示请求已经被处理了
  14.     mavContainer.setRequestHandled(true);
  15.     ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
  16.     ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
  18.     //2：将结果输出到客户端
  19.     writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
  20. }

上面代码中，这里大家需要注意handleReturnValue方法，这个方法内部会直接将结果输出，后续就没有视图渲染的事情了，所以这里会调用mavContainer.setRequestHandled(true)，表示请求已经处理了。

2.7、⑥：调用拦截器的postHandle方法

  1. //⑥：调用拦截器的postHandle方法
  2. mappedHandler.applyPostHandle(processedRequest, response, mv);

mappedHandler.applyPostHandle源码如下，逆序调用拦截器的postHandle方法

  1. org.springframework.web.servlet.HandlerExecutionChain#applyPostHandle
  3. void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
  4.     throws Exception {
  6.     for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
  7.         HandlerInterceptor interceptor = this.interceptorList.get(i);
  8.         interceptor.postHandle(request, response, this.handler, mv);
  9.     }
  10. }

2.8、⑦：渲染视图

2.8.1、过程

  1.  //⑦：处理分发结果，渲染视图(包含了正常处理和异常情况的处理)，将结果输出到客户端
  2.  processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

processDispatchResult源码如下

  1. org.springframework.web.servlet.DispatcherServlet#processDispatchResult
  3. private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
  4.                                    @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
  5.                                    @Nullable Exception exception) throws Exception {
  6.     boolean errorView = false;
  8.     if (exception != null) {
  9.         Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
  10.         //⑦-1：如果有异常，进行全局异常处理
  11.         mv = processHandlerException(request, response, handler, exception);
  12.         errorView = (mv != null);
  13.     }
  15.     if (mv != null && !mv.wasCleared()) {
  16.         //⑦-2：渲染视图
  17.         render(mv, request, response);
  18.         if (errorView) {
  19.             //调用request.removeAttribute方法清理request中错误信息
  20.             WebUtils.clearErrorRequestAttributes(request);
  21.         }
  22.     }
  24.     if (mappedHandler != null) {
  25.         //⑦-3：调用拦截器的afterCompletion方法
  26.         mappedHandler.triggerAfterCompletion(request, response, null);
  27.     }
  28. }

这个方法主要干了3个事情

  • step1：⑦-1：如果有异常，进行全局异常处理
  • step2：⑦-2：渲染视图
  • step3：⑦-3：调用拦截器的afterCompletion方法

下面来解析这3个步骤

2.8.2、step1：⑦-1：如果有异常，进行全局异常处理

  1. if (exception != null) {
  2.     Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
  3.     //⑦-1：如果有异常，进行全局异常处理
  4.     mv = processHandlerException(request, response, handler, exception);
  5.     errorView = (mv != null);
  6. }

processHandlerException方法源码，主要是遍历异常处理器HandlerExceptionResolver的resolveException来处理异常，稍后会说一下这个接口

  1. org.springframework.web.servlet.DispatcherServlet#processHandlerException
  3. protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
  4.             @Nullable Object handler, Exception ex) throws Exception {
  6.     // 调用处理器异常解析器解析异常，得到ModelAndView
  7.     ModelAndView exMv = null;
  8.     if (this.handlerExceptionResolvers != null) {
  9.         for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
  10.             exMv = resolver.resolveException(request, response, handler, ex);
  11.             if (exMv != null) {
  12.                 break;
  13.             }
  14.         }
  15.     }
  16.     if (exMv != null) {
  17.         //暴露异常信息到request对象中（request.setAttribute）
  18.         WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
  19.         return exMv;
  20.     }
  22.     throw ex;
  23. }

HandlerExceptionResolver接口：处理器异常解析器，内部就只有一个方法，用来解析异常的，得到一个ModelAndView对象。

  1. public interface HandlerExceptionResolver {
  3.     @Nullable
  4.     ModelAndView resolveException(
  5.             HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
  7. }

这个接口有好几个实现类，我们主要关注下ExceptionHandlerExceptionResolver这个类，大家是否还记得注解方式处理全局异常（），最终这俩注解定义的异常处理会被ExceptionHandlerExceptionResolver这个类进行处理，这个类的源码就不细讲了，比较简单，大家可以去看看，就是一个异常类型匹配处理方法的过程。

2.8.3、step2：⑦-2：渲染视图

  1. //⑦-2：渲染视图
  2. render(mv, request, response);

render方法源码如下

  1. org.springframework.web.servlet.DispatcherServlet#render
  3. protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
  4.     View view;
  5.     String viewName = mv.getViewName();
  6.     if (viewName != null) {
  7.         //⑦-2-1：调用视图解析器解析视图名称得到视图View对象
  8.         view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
  9.     } else {
  10.         view = mv.getView();
  11.     }
  13.     //⑦-2-2：调用视图的render方法渲染视图，将结果输出到客户端
  14.     view.render(mv.getModelInternal(), request, response);
  15. }

此方法干了2件事

  • ⑦-2-1：调用视图解析器解析视图名称得到视图View对象
  • ⑦-2-2：调用视图的render方法渲染视图，将结果输出到客户端

下面进去细看一下

⑦-2-1：调用视图解析器解析视图名称得到视图View对象
  1. //⑦-2-1：调用视图解析器解析视图名称得到视图View对象
  2. view = resolveViewName(viewName, mv.getModelInternal(), locale, request);

resolveViewName方法源码如下，遍历视图解析器，解析视图名称，得到视图对象View

  1. protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
  2.             Locale locale, HttpServletRequest request) throws Exception {
  4.     if (this.viewResolvers != null) {
  5.         for (ViewResolver viewResolver : this.viewResolvers) {
  6.             View view = viewResolver.resolveViewName(viewName, locale);
  7.             if (view != null) {
  8.                 return view;
  9.             }
  10.         }
  11.     }
  12.     return null;
  13. }
⑦-2-2：调用视图的render方法渲染视图，将结果输出到客户端
  1. //⑦-2-2：调用视图的render方法渲染视图，将结果输出到客户端
  2. view.render(mv.getModelInternal(), request, response);

这里我们以InternalResourceView为例，进到其render方法中，看看里面干了什么，最终会进到其renderMergedOutputModel方法中，源码如下，这里代码就非常亲切了，不多解释，看注释

  1. protected void renderMergedOutputModel(
  2.         Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  4.     // 将model中的数据遍历后放在request中（request.setAttribute(name,value)）
  5.     exposeModelAsRequestAttributes(model, request);
  7.     // 获取跳转的页面的路径
  8.     String dispatcherPath = prepareForRendering(request, response);
  10.     // 调用request.getRequestDispatcher(path)得到RequestDispatcher对象
  11.     RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
  13.     //实现页面跳转
  14.     if (useInclude(request, response)) {
  15.         rd.include(request, response);
  16.     }else {
  17.         rd.forward(request, response);
  18.     }
  19. }

2.8.3、step3：⑦-3：调用拦截器的afterCompletion方法

  1. ⑦-3：调用拦截器的afterCompletion方法
  2. mappedHandler.triggerAfterCompletion(request, response, null);

mappedHandler.triggerAfterCompletion方法的源码如下，反向调用拦截器的afterCompletion方法

  1. void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
  2.     for (int i = this.interceptorIndex; i >= 0; i--) {
  3.         HandlerInterceptor interceptor = this.interceptorList.get(i);
  4.         try {
  5.             interceptor.afterCompletion(request, response, this.handler, ex);
  6.         }
  7.         catch (Throwable ex2) {
  8.             logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
  9.         }
  10.     }
  11. }

过程到这里就结束了，需要大家结合源码多看几遍，还是比较容易的。

3、处理流程：纯文字描述

1、用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获

2、DispatcherServlet根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回

4、DispatcherServlet 根据获得的 Handler，选择一个合适的HandlerAdapter

5、如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler(…)方法【正向】

6、提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)方法，处理请求，在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

  1. HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的类型信息

  2. 数据转换：对请求消息进行数据转换。如String转换成Integer、Double等

  3. 数据格式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等

  4. 数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

7、Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象。

8、此时将开始执行拦截器的postHandle(…)方法【逆向】

9、根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model和View，来渲染视图

10、渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】

11、将渲染结果返回给客户端

4、小结

本文东西比较多，建议大家抽空结合源码多看几遍，下一篇文章将通过源码介绍springmvc容器的启动过程，干货也是满满的，敬请期待。

5、案例代码

  1. git地址：https://gitee.com/javacode2018/springmvc-series

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#SpringMVC教程
阅读全部
相关文章推荐
  • 1

全部评论: 0 条

    我有话说: