Spring MVC 的核心流程是什么？其实就是一个请求访问某个资源时，会解析 Request Params，最后落到具体的 Controller，再由 Controller 中的逻辑进行相关的业务处理，最后将结果返回给客户端的过程。

我们直到 Spring MVC 核心就是 DispatcherServlet，既然时一个 Servlet，那么就一定由 doGet 和 doPost 方法，我们就从这里开始研究

我们先缕一缕 Spring MVC 加载 handler 的流程

  1. 初始化（查找）所有 @Controller 或 @RequestMapping 的注解（这里会牵扯到父子容器的概念）
  2. 扫描所有 @RequestMappting 的方法
  3. 将 @RequestMappting 的路径和方法绑定在一起，并加入到一个 Map 中去

初始化 @Controller 注解

Spring MVC 通过实现 InitializingBean，重写 afterPropertiesSet() 方法，来完成方法或类的 URI 映射关系

  1. @Override
  2. public void afterPropertiesSet() {
  3.     // ★★★ 关键代码：初始化 @Controller 的方法，并生成映射关系
  4.     initHandlerMethods();
  5. }

（1）找到符合要求的 bean

获取所有的 bean，并处理符合要求的 bean，符合要求是指类名上含有 @Controller 或 @RequestMapping

  1. protected void     initHandlerMethods() {
  2.     // 遍历 bean 的名称
  3.     for (String beanName : getCandidateBeanNames()) {
  4.         if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
  5.             // 处理 bean
  6.             processCandidateBean(beanName);
  7.         }
  8.     }
  9.     handlerMethodsInitialized(getHandlerMethods());
  10. }
  12. protected void processCandidateBean(String beanName) {
  13.     Class<?> beanType = null;
  14.     try {
  15.         // 获取 bean 的类对象
  16.         beanType = obtainApplicationContext().getType(beanName);
  17.     }
  18.     catch (Throwable ex) {
  19.         // An unresolvable bean type, probably from a lazy bean - let's ignore it.
  20.         if (logger.isTraceEnabled()) {
  21.             logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
  22.         }
  23.     }
  24.     // 判断是否是一个 handler
  25.     // 有没有 @Controller 或者 @RequestMapping 注解
  26.     if (beanType != null && isHandler(beanType)) {
  27.         // 推断 加了 @RequestMapping 的方法，并注册到 mappingRegistry
  28.         detectHandlerMethods(beanName);
  29.     }
  30. }
  32. @Override
  33. protected boolean isHandler(Class<?> beanType) {
  34.     return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
  35.             AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
  36. }

（2）推断符合要求的方法

当找到了符合要求的 bean 之后，就开始推断符合要求的方法或类，并将其进行注册

  1. protected void detectHandlerMethods(Object handler) {
  2.     Class<?> handlerType = (handler instanceof String ?
  3.                             obtainApplicationContext().getType((String) handler) : handler.getClass());
  5.     if (handlerType != null) {
  6.         Class<?> userType = ClassUtils.getUserClass(handlerType);
  7.         // 获取所有方法 key = method, value = RequestMappingInfo
  8.         Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
  9.                 (MethodIntrospector.MetadataLookup<T>) method -> {
  10.                     try {
  11.                         // ★★★ 返回有 @RequestMapping 的方法，并封装为 RequestMappingInfo
  12.                         return getMappingForMethod(method, userType);
  13.                     }
  14.                     catch (Throwable ex) {
  15.                         throw new IllegalStateException("Invalid mapping on handler class [" +
  16.                                                         userType.getName() + "]: " + method, ex);
  17.                     }
  18.                 });
  19.         if (logger.isTraceEnabled()) {
  20.             logger.trace(formatMappings(userType, methods));
  21.         }
  22.         methods.forEach((method, mapping) -> {
  23.             Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
  24.             // 注册到 mappingRegistry 中
  25.             // 也就是注册到 urlLookup Map 中去，key = uri, value = RequestMappingInfo
  26.             registerHandlerMethod(handler, invocableMethod, mapping);
  27.         });
  28.     }
  29. }

（3）注册到 urlLookup 中

  1. protected void registerHandlerMethod(Object handler, Method method, T mapping) {
  2.     this.mappingRegistry.register(mapping, handler, method);
  3. }
  5. public void register(T mapping, Object handler, Method method) {
  6.     this.readWriteLock.writeLock().lock();
  7.     try {
  8.         HandlerMethod handlerMethod = createHandlerMethod(handler, method);
  9.         assertUniqueMethodMapping(handlerMethod, mapping);
  10.         this.mappingLookup.put(mapping, handlerMethod);
  12.         List<String> directUrls = getDirectUrls(mapping);
  13.         for (String url : directUrls) {
  14.             // ★★★ 关键代码：加入 urlLookup
  15.             this.urlLookup.add(url, mapping);
  16.         }
  18.         String name = null;
  19.         if (getNamingStrategy() != null) {
  20.             name = getNamingStrategy().getName(handlerMethod, mapping);
  21.             addMappingName(name, handlerMethod);
  22.         }
  24.         CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
  25.         if (corsConfig != null) {
  26.             this.corsLookup.put(handlerMethod, corsConfig);
  27.         }
  29.         this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
  30.     }
  31.     finally {
  32.         this.readWriteLock.writeLock().unlock();
  33.     }
  34. }

客户端调用

image.png

  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.     HttpServletRequest processedRequest = request;
  3.     HandlerExecutionChain mappedHandler = null;
  4.     boolean multipartRequestParsed = false;
  6.     // 异步编程（webflux）
  7.     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  9.     try {
  10.         ModelAndView mv = null;
  11.         Exception dispatchException = null;
  13.         try {
  14.             // ★★★ 检查请求是否有上传文件操作
  15.             processedRequest = checkMultipart(request);
  16.             multipartRequestParsed = (processedRequest != request);
  18.             /*
  19.                 Determine handler for the current request.
  21.                 ★★★ 推断当前请求（Controller）的处理程序
  22.                 关键代码：返回一个 MappedHandler 对象，里面包括要执行的方法以及对应的方法参数
  23.                 处理 handler 由两大类型
  24.                 1、加上了 @Controller 注解：RequestMappingHandlerMapping
  25.                 2、beanName 形式：BeanNameUrlHandlerMapping
  26.                  */
  27.             mappedHandler = getHandler(processedRequest);
  28.             if (mappedHandler == null) {
  29.                 // 返回 404
  30.                 noHandlerFound(processedRequest, response);
  31.                 return;
  32.             }
  34.             /*
  35.                 Determine handler adapter for the current request.
  37.                 ★★★ 关键代码：确定当前请求的 handler 的 Adapter（3种方式）
  38.                 1、加上了 @Controller 注解：
  39.                     mappedHandler.getHandler() 返回一个：方法
  40.                     HandlerAdapter = RequestMappingHandlerAdapter
  41.                 2、继承 Controller 接口：
  42.                     mappedHandler.getHandler() 返回一个：bean
  43.                     HandlerAdapter = SimpleControllerHandlerAdapter
  44.                 3、继承 HttpRequestHandler 接口：
  45.                     mappedHandler.getHandler() 返回一个：bean
  46.                     HandlerAdapter = HttpRequestHandlerAdapter
  47.                  */
  48.             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  50.             // Process last-modified header, if supported by the handler.
  51.             // 获取请求类型
  52.             String method = request.getMethod();
  54.             // 是否是 GET 请求方式
  55.             boolean isGet = "GET".equals(method);
  56.             if (isGet || "HEAD".equals(method)) {
  57.                 // 检查最后修改
  58.                 long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
  59.                 // 从浏览器缓存读取
  60.                 if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
  61.                     return;
  62.                 }
  63.             }
  65.             // 前置拦截器处理
  66.             if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  67.                 return;
  68.             }
  70.             // Actually invoke the handler.
  71.             // 关键代码：开始执行方法，返回一个 ModelAndView 对象
  72.             // 1、如果是 beanName 的方式就比较简单，直接调用接口的实现类的方法即可
  73.             // 2、如果是 @Controller 的方式，就是 RequestMappingHandlerAdapter
  74.             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  76.             if (asyncManager.isConcurrentHandlingStarted()) {
  77.                 return;
  78.             }
  79.             // 尝试解析一个默认视图
  80.             applyDefaultViewName(processedRequest, mv);
  81.             mappedHandler.applyPostHandle(processedRequest, response, mv);
  82.         } catch (Exception ex) {
  83.             dispatchException = ex;
  84.         } catch (Throwable err) {
  85.             // As of 4.3, we're processing Errors thrown from handler methods as well,
  86.             // making them available for @ExceptionHandler methods and other scenarios.
  87.             dispatchException = new NestedServletException("Handler dispatch failed", err);
  88.         }
  89.         // 关键代码：尝试开始解析视图
  90.         processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  91.     } catch (Exception ex) {
  92.         triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
  93.     } catch (Throwable err) {
  94.         triggerAfterCompletion(processedRequest, response, mappedHandler,
  95.                                new NestedServletException("Handler processing failed", err));
  96.     } finally {
  97.         if (asyncManager.isConcurrentHandlingStarted()) {
  98.             // Instead of postHandle and afterCompletion
  99.             if (mappedHandler != null) {
  100.                 mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
  101.             }
  102.         } else {
  103.             // Clean up any resources used by a multipart request.
  104.             if (multipartRequestParsed) {
  105.                 cleanupMultipart(processedRequest);
  106.             }
  107.         }
  108.     }
  109. }

如何判断是走视图跳转还是JSON

1、@ResponseBody 的形式

先通过 selectHandler 查找一个 handler，如果是 @ResponseBody 注解的话，会找到 RequestResponseBodyMethodProcessor 来处理，判断方式如下：看方法和返回值上是否有该注解

  1. @Override
  2. public boolean supportsReturnType(MethodParameter returnType) {
  3.     return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) ||
  4.             returnType.hasMethodAnnotation(ResponseBody.class));
  5. }

如果符合条件的话，就会尝试在从 messageConverters 中寻找 JSON 的消息解析器，进行解析，返回到页面

2、String 类型的返回形式

先通过 selectHandler 查找一个 handler，如果返回 String 的话，并且方法返回时 Void，会找到 RequestResponseBodyMethodProcessor 来处理，判断方式如下：

  1. @Override
  2. public boolean supportsReturnType(MethodParameter returnType) {
  3.     Class<?> paramType = returnType.getParameterType();
  4.     return (void.class == paramType || CharSequence.class.isAssignableFrom(paramType));
  5. }

如果符合条件的话，将返回值作为视图的名称，设置到 ModelAndViewContainer 中，在判断是否是重定向视图，即 redirect: 开头的字符串，如果是的话：ModelAndViewContainer 设置为重定向

  1. public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
  2.             ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
  4.     if (returnValue instanceof CharSequence) {
  5.         String viewName = returnValue.toString();
  6.         // 设置视图名称
  7.         mavContainer.setViewName(viewName);
  8.         // 是否包含 redirect: 前缀
  9.         if (isRedirectViewName(viewName)) {
  10.             mavContainer.setRedirectModelScenario(true);
  11.         }
  12.     }
  13.     else if (returnValue != null) {
  14.         // should not happen
  15.         throw new UnsupportedOperationException("Unexpected return type: " +
  16.                                                 returnType.getParameterType().getName() + " in method: " + returnType.getMethod());
  17.     }
  18. }
  20. protected boolean isRedirectViewName(String viewName) {
  21.     return (PatternMatchUtils.simpleMatch(this.redirectPatterns, viewName) 
  22.             || viewName.startsWith("redirect:"));
  23. }

当封装好 ModelAndViewContainer 后（里面已经包含视图名称和是否重定向）开始创建一个 ModelAndView 对象，其实就是 new 了一个 ModelAndView，分别开始处理 Model 和 View

  1. @Nullable
  2. private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
  3.                                      ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
  4.     // 处理 Model
  5.     modelFactory.updateModel(webRequest, mavContainer);
  7.     // 关键代码：如果不需要返回视图，则直接返回 null
  8.     if (mavContainer.isRequestHandled()) {
  9.         return null;
  10.     }
  11.     ModelMap model = mavContainer.getModel();
  12.     ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
  13.     // 检查是不是一个 View 对象，其实就是看看是不是 String
  14.     if (!mavContainer.isViewReference()) {
  15.         mav.setView((View) mavContainer.getView());
  16.     }
  17.     // 判断是不是 重定向 的参数
  18.     // 即方法中含有 RedirectAttributes 参数，该参数可以传递重定向的参数值
  19.     if (model instanceof RedirectAttributes) {
  20.         Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
  21.         HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
  22.         if (request != null) {
  23.             RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
  24.         }
  25.     }
  26.     return mav;
  27. }

此时 ModelAndView 对象就已经初始化完成了，下一步开始渲染视图

先通过视图解析器，根据视图名称，查找所需要的视图，然后返回给浏览器，其实核心就是调用转发来实现视图跳转：

  • 如果手动关闭输出流：RequestDispatcher.include(request, response);
  • 如果没有关闭输出流：RequestDispatcher.forward(request, response);

**

  1. @Override
  2. protected void renderMergedOutputModel(
  3.     Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  5.     // Expose the model object as request attributes.
  6.     exposeModelAsRequestAttributes(model, request);
  8.     // Expose helpers as request attributes, if any.
  9.     exposeHelpers(request);
  11.     // Determine the path for the request dispatcher.
  12.     String dispatcherPath = prepareForRendering(request, response);
  14.     // Obtain a RequestDispatcher for the target resource (typically a JSP).
  15.     RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
  16.     if (rd == null) {
  17.         throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
  18.                                    "]: Check that the corresponding file exists within your web application archive!");
  19.     }
  21.     // If already included or response already committed, perform include, else forward.
  22.     // 判断 输出流 有没有关闭
  23.     if (useInclude(request, response)) {
  24.         response.setContentType(getContentType());
  25.         if (logger.isDebugEnabled()) {
  26.             logger.debug("Including [" + getUrl() + "]");
  27.         }
  28.         // 如果已经手动关闭了输出流 response.getWriter().close()
  29.         // 就使用 RequestDispatcher.include(request, response);
  30.         rd.include(request, response);
  31.     }
  33.     else {
  34.         // Note: The forwarded resource is supposed to determine the content type itself.
  35.         if (logger.isDebugEnabled()) {
  36.             logger.debug("Forwarding to [" + getUrl() + "]");
  37.         }
  38.         // ★★★ 关键代码
  39.         // 如果没有关闭输出流 response.getWriter().close()
  40.         // 其实就是 RequestDispatcher.forward(request, response);
  41.         rd.forward(request, response);
  42.     }
  43. }

3、ModelAndView 返回形式

ModelAndView 的形式和 String 的形式类似，只是处理返回值的 handler 是 ModelAndViewMethodReturnValueHandler

  1. @Override
  2. public boolean supportsReturnType(MethodParameter returnType) {
  3.     return ModelAndView.class.isAssignableFrom(returnType.getParameterType());
  4. }

接下来，开始处理 ModelAndView

  1. @Override
  2. public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
  3.                               ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
  5.     if (returnValue == null) {
  6.         mavContainer.setRequestHandled(true);
  7.         return;
  8.     }
  10.     ModelAndView mav = (ModelAndView) returnValue;
  11.     // 判断 view 是不是 String
  12.     if (mav.isReference()) {
  13.         String viewName = mav.getViewName();
  14.         mavContainer.setViewName(viewName);
  15.         if (viewName != null && isRedirectViewName(viewName)) {
  16.             mavContainer.setRedirectModelScenario(true);
  17.         }
  18.     }
  19.     else {
  20.         View view = mav.getView();
  21.         mavContainer.setView(view);
  22.         if (view instanceof SmartView && ((SmartView) view).isRedirectView()) {
  23.             mavContainer.setRedirectModelScenario(true);
  24.         }
  25.     }
  26.     mavContainer.setStatus(mav.getStatus());
  27.     // 设置传递需要的参数
  28.     mavContainer.addAllAttributes(mav.getModel());
  29. }

此时 ModelAndView 对象就已经初始化完成了，下一步开始渲染视图

先通过视图解析器，根据视图名称，查找所需要的视图，然后返回给浏览器，其实核心就是调用转发来实现视图跳转：

  • 如果手动关闭输出流：RequestDispatcher.include(request, response);
  • 如果没有关闭输出流：RequestDispatcher.forward(request, response);