SpringMVC源码剖析

SpringMVC源码剖析

学习资料：拉勾课程《Java高薪训练营》

1. 前端控制器DispatcherServlet继承结构

2. SpringMVC处理请求的大致流程

2.1 Handler⽅法的执⾏时机

打断点

观察调用栈 ： doDispathch⽅法中的1064⾏代码完成handler⽅法的调⽤

2.2 ⻚⾯渲染时机（打断点并观察调⽤栈）

观察调用栈，调用的是doDispatch方法，该方法又调用了processDispatchResult方法

2.3 SpringMVC处理请求的流程即为

org.springframework.web.servlet.DispatcherServlet#doDispatch⽅法的执⾏过程，其中步骤②、 ③、 ④、 ⑤是核⼼步骤

①检查是否是文件上传的请求
②调⽤getHandler()获取到能够处理当前请求的执⾏链 HandlerExecutionChain（Handler+拦截器）
​ 但是如何去getHandler的？后⾯进⾏分析
③调⽤getHandlerAdapter()；获取能够执⾏①中Handler的适配器
​ 但是如何去getHandlerAdapter的？后⾯进⾏分析
④适配器调⽤Handler执⾏ha.handle（总会返回⼀个ModelAndView对象）
⑤调⽤processDispatchResult()⽅法完成视图渲染跳转

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   HttpServletRequest processedRequest = request;
   //handler执行器链，包含handler以及一些拦截器
   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，这里也称为Handler，即处理器
              这里并不是直接返回 Controller，而是返回 HandlerExecutionChain 请求处理链对象
              该对象封装了Handler和Inteceptor
          */
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null) {
            // 如果 handler 为空，则返回404
            noHandlerFound(processedRequest, response);
            return;
         }

         // Determine handler adapter for the current request.
         // 3 获取处理请求的处理器适配器 HandlerAdapter
         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 (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);
      }
      //5 跳转视图页面，渲染视图
      processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
   }
   catch (Exception ex) {
      //最终会调用HandlerInterceptor的afterCompletion 方法
      triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
   }
   catch (Throwable err) {
      //最终会调用HandlerInterceptor的afterCompletion 方法
      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);
         }
      }
   }
}

3. 源码剖析之getHandler方法分析

   遍历两个HandlerMapping，试图获取能够处理当前请求的执⾏链
   

4. 源码剖析之getHandlerAdapter适配器获取分析

   遍历各个HandlerAdapter，看哪个Adapter⽀持处理当前Handler
   

5. 源码剖析之Handler方法执行细节剖析

   5.1入口
   
   5.2 断点从⼊⼝进⼊
   
   5.3 invokeHandlerMethod方法

   protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
                                    HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
   
      ServletWebRequest webRequest = new ServletWebRequest(request, response);
      try {
         // 获取容器中全局配置的InitBinder和当前HandlerMethod所对应的Controller中配置的InitBinder，用于进行参数的绑定
         WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
         // 获取容器中全局配置的ModelAttribute和当前当前HandlerMethod所对应的Controller中配置的ModelAttribute，这些配置的方法将会在目标方法调用之前进行调用
         ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
   
         // 将handlerMethod封装为一个ServletInvocableHandlerMethod对象
         ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
         if (this.argumentResolvers != null) {
            // 设置当前容器中配置的所有ArgumentResolver
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
         }
         if (this.returnValueHandlers != null) {
            // 设置当前容器中配置的所有ReturnValueHandler
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
         }
         // 将前面创建的WebDataBinderFactory设置到ServletInvocableHandlerMethod中
         invocableMethod.setDataBinderFactory(binderFactory);
   
         invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
   
         ModelAndViewContainer mavContainer = new ModelAndViewContainer();
         mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
         // 这里initModel()方法主要作用是调用前面获取到的@ModelAttribute标注的方法，
         // 从而达到@ModelAttribute标注的方法能够在目标Handler调用之前调用的目的
         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);
         }
   
         // 对请求参数进行处理，调用目标HandlerMethod，并且将返回值封装为一个ModelAndView对象
         invocableMethod.invokeAndHandle(webRequest, mavContainer);
         if (asyncManager.isConcurrentHandlingStarted()) {
            return null;
         }
   
         // 对封装的ModelAndView进行处理，主要是判断当前请求是否进行了重定向，如果进行了重定向，
         // 还会判断是否需要将FlashAttributes封装到新的请求中
         return getModelAndView(mavContainer, modelFactory, webRequest);
      }
      finally {
         webRequest.requestCompleted();
      }
   }
   

   5.4 invokeAndHandle方法
   
   5.5 invokeForRequest方法
   
   5.6 getMethodArgumentValues方法

   /**
    * Get the method argument values for the current request, checking the provided
    * argument values and falling back to the configured argument resolvers.
    * <p>The resulting array will be passed into {@link #doInvoke}.
    * @since 5.1.2
    * 本方法主要是通过当前容器中配置的ArgumentResolver对request中的参数进行转化，
    * 将其处理为目标handler的参数的形式
    */
   protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
                                    Object... providedArgs) throws Exception {
   
      // 获取当前handler所声明的所有参数，主要包括参数名，参数类型，参数位置，所标注的注解等等属性
      MethodParameter[] parameters = getMethodParameters();
      if (ObjectUtils.isEmpty(parameters)) {
         return EMPTY_ARGS;
      }
   
      Object[] args = new Object[parameters.length];
      for (int i = 0; i < parameters.length; i++) {
         MethodParameter parameter = parameters[i];
         parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
         // providedArgs是调用方提供的参数，这里主要是判断这些参数中是否有当前类型，如果有，则直接使用调用方提供的参数，对于请求处理而言，默认情况下，
         // 调用方提供的参数都是长度为0的数组
         args[i] = findProvidedArgument(parameter, providedArgs);
         if (args[i] != null) {
            continue;
         }
         // 如果在调用方提供的参数中不能找到当前类型的参数值，则遍历Spring容器中所有的
         // ArgumentResolver，判断哪种类型的Resolver支持对当前参数的解析，这里的判断
         // 方式比较简单，比如RequestParamMethodArgumentResolver就是判断当前参数
         // 是否使用@RequestParam注解进行了标注
         if (!this.resolvers.supportsParameter(parameter)) {
            throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
         }
         try {
            // 如果能够找到对当前参数进行处理的ArgumentResolver，则调用其
            // resolveArgument()方法从request中获取对应的参数值，并且进行转换
            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;
   }
   

6. 源码剖析之视图渲染(processDispatchResult)细节剖析

   6.1 render⽅法完成渲染
   
   
   6.2 resolveViewName方法
   
   6.3 在解析出View视图对象的过程中会判断是否重定向、是否转发等，不同的情况封装的是不同的View实现
   
   6.4 解析出View视图对象的过程中，要将逻辑视图名解析为物理视图名
   
   6.5 封装View视图对象之后，调⽤了view对象的render⽅法
   
   6.6 渲染数据
   
   6.7 把modelMap中的数据暴露到request域中，这也是为什么后台model.add之后在jsp中可以从请求域取出来的根本原因
   
   6.8 将数据设置到请求域中
   

7. 源码剖析之SpringMVC九大组件初始

   7.1 在DispatcherServlet中定义了九个属性，每⼀个属性都对应⼀种组件

   /** MultipartResolver used by this servlet. */
   //多部件解析器
   @Nullable
   private MultipartResolver multipartResolver;
   
   /** LocaleResolver used by this servlet. */
   //区域化 ， 国际化解析器
   @Nullable
   private LocaleResolver localeResolver;
   
   /** ThemeResolver used by this servlet. */
   //主题解析器
   @Nullable
   private ThemeResolver themeResolver;
   
   /** List of HandlerMappings used by this servlet. */
   //处理器映射器组件
   @Nullable
   private List<HandlerMapping> handlerMappings;
   
   /** List of HandlerAdapters used by this servlet. */
   //处理器适配器组件
   @Nullable
   private List<HandlerAdapter> handlerAdapters;
   
   /** List of HandlerExceptionResolvers used by this servlet. */
   //异常解析器组件
   @Nullable
   private List<HandlerExceptionResolver> handlerExceptionResolvers;
   
   /** RequestToViewNameTranslator used by this servlet. */
   //默认视图名转换器组件
   @Nullable
   private RequestToViewNameTranslator viewNameTranslator;
   
   /** FlashMapManager used by this servlet. */
   //flash属性管理组件
   @Nullable
   private FlashMapManager flashMapManager;
   
   /** List of ViewResolvers used by this servlet. */
   //视图解析器
   @Nullable
   private List<ViewResolver> viewResolvers;
   

   九⼤组件都是定义了接⼝，接⼝其实就是定义了该组件的规范，⽐如ViewResolver、 HandlerAdapter等都是接⼝

   7.2源码剖析之SpringMVC九大组件初始化细节

   7.2.1 DispatcherServlet中的onRefresh()，该⽅法中初始化了九⼤组件
   
   7.2.2 观察其中的⼀个组件initHandlerMappings(context)

   private void initHandlerMappings(ApplicationContext context) {
      this.handlerMappings = null;
   
      if (this.detectAllHandlerMappings) {
         // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
         // 按照HandlerMapping.class类型去IOC容器中找到所有的HandlerMapping
         Map<String, HandlerMapping> matchingBeans =
               BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
         if (!matchingBeans.isEmpty()) {
            this.handlerMappings = new ArrayList<>(matchingBeans.values());
            // We keep HandlerMappings in sorted order.
            AnnotationAwareOrderComparator.sort(this.handlerMappings);
         }
      }
      else {
         try {
            // 否则在ioc中按照固定名称id(handlerMapping)去找
            HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
            this.handlerMappings = Collections.singletonList(hm);
         }
         catch (NoSuchBeanDefinitionException ex) {
            // Ignore, we'll add a default HandlerMapping later.
         }
      }
   
      // Ensure we have at least one HandlerMapping, by registering
      // a default HandlerMapping if no other mappings are found.
      if (this.handlerMappings == null) {
         // 最后还为空则按照默认策略生成
         //按照默认方式实例化生成HandlerMapping
         this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
         if (logger.isTraceEnabled()) {
            logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
                  "': using default strategies from DispatcherServlet.properties");
         }
      }
   }
   

   7.2.3 如果按照类型和按照固定id从ioc容器中找不到对应组件，则会按照默认策略进⾏注册初始化，默认策略在DispatcherServlet.properties⽂件中配置

   protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
      String key = strategyInterface.getName();
      String value = defaultStrategies.getProperty(key);
      if (value != null) {
         String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
         List<T> strategies = new ArrayList<>(classNames.length);
         for (String className : classNames) {
            try {
               Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
               Object strategy = createDefaultStrategy(context, clazz);
               strategies.add((T) strategy);
            }
            catch (ClassNotFoundException ex) {
               throw new BeanInitializationException(
                     "Could not find DispatcherServlet's default strategy class [" + className +
                           "] for interface [" + key + "]", ex);
            }
            catch (LinkageError err) {
               throw new BeanInitializationException(
                     "Unresolvable class definition for DispatcherServlet's default strategy class [" +
                           className + "] for interface [" + key + "]", err);
            }
         }
         return strategies;
      }
      else {
         return new LinkedList<>();
      }
   }
   

   7.2.4 DispatcherServlet.properties
   
   7.2.5 注意：多部件解析器的初始化(initMultipartResolver)必须按照id注册对象（multipartResolver）

   private void initMultipartResolver(ApplicationContext context) {
      try {
         this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
         if (logger.isTraceEnabled()) {
            logger.trace("Detected " + this.multipartResolver);
         }
         else if (logger.isDebugEnabled()) {
            logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName());
         }
      }
      catch (NoSuchBeanDefinitionException ex) {
         // Default is no multipart resolver.
         this.multipartResolver = null;
         if (logger.isTraceEnabled()) {
            logger.trace("No MultipartResolver '" + MULTIPART_RESOLVER_BEAN_NAME + "' declared");
         }
      }
   }