SpringMVC源码分析之策略对象初始化-CFANZ编程社区

前面我们分析了springmvc的各种组件，那么组件在什么时候初始化的呢？我们这里就研究一下。

【1】DispatcherServlet

① 核心属性

DispatcherServlet有许多属性，除了一些 static final类型的常量，其他类似如List<HandlerMapping> handlerMappings是在实例化过程中赋值的。

// 如下是一些静态常量，默认类加载时已赋值
public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";
public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";
public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";
public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";
public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";
public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";
// 下面是请求属性部分key
public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() + ".CONTEXT";
public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".LOCALE_RESOLVER";
public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_RESOLVER";
public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_SOURCE";
public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".INPUT_FLASH_MAP";
public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".OUTPUT_FLASH_MAP";
public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + ".FLASH_MAP_MANAGER";
public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + ".EXCEPTION";
public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";
// DispatcherServlet.properties 里面可以配置了一些策略接口的默认值，
//比如 HandlerMapping=RequestMappingHandlerMapping
private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
private static final String DEFAULT_STRATEGIES_PREFIX = "org.springframework.web.servlet";
protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);

/** Store default strategy implementations. */
@Nullable
private static Properties defaultStrategies;
// 下面这些属性在实例化调用构造函数时会被重新赋值
/** Detect all HandlerMappings or just expect "handlerMapping" bean?. */
private boolean detectAllHandlerMappings = true;

/** Detect all HandlerAdapters or just expect "handlerAdapter" bean?. */
private boolean detectAllHandlerAdapters = true;

/** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean?. */
private boolean detectAllHandlerExceptionResolvers = true;

/** Detect all ViewResolvers or just expect "viewResolver" bean?. */
private boolean detectAllViewResolvers = true;

/** Throw a NoHandlerFoundException if no Handler was found to process this request? *.*/
private boolean throwExceptionIfNoHandlerFound = false;

/** Perform cleanup of request attributes after include request?. */
private boolean cleanupAfterInclude = true;

// 下面这些属性将在initStrategies方法中被调用
/** 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. */
@Nullable
private FlashMapManager flashMapManager;

/** List of ViewResolvers used by this servlet. */
@Nullable
private List<ViewResolver> viewResolvers;

private boolean parseRequestPath;

我们下面要分析的就是诸如viewResolvers、handlerExceptionResolvers等在何时被实例化并注入。

② 继承树

如下所示是DispatcherServlet的继承树示意图，其继承自FrameworkServlet，而FrameworkServlet又继承了HttpServletBean并实现了ApplicationContextAware接口。

HttpServletBean 则继承了HttpServlet 并实现 EnvironmentCapable, EnvironmentAware接口。所以本质上DispatcherServlet是一个httpservlet，当实例化bean时会调用其init方法。
SpringMVC源码分析之策略对象初始化_spring
我们就从其init方法入手分析。

首先会调用DispatcherServlet的无参构造方法，这里会为其成品变量赋值。

public DispatcherServlet() {
  super();
  setDispatchOptionsRequest(true);
}

然后会调用其父类GenericServlet的init(ServletConfig config)方法，其子类HttpServletBean重写了父类GenericServlet的void init()方法,方法如下所示主要是获取初始化参数为servlet 成员赋值，然后调用initServletBean方法。但是这是一个空方法，留给子类FrameworkServlet实现。

web容器在实例化servlet时会调用Servlet的init(ServletConfig)方法，由于其子类GenericServlet实现了该方法，因而最终会调用GenericServlet.init(ServletConfig)方法。
GenericServlet.init(ServletConfig)方法内部会调用其init()方法，由于该方法又是由其子类HttpServletBean实现,实际上是执行了HttpServletBean.init()方法。
HttpServletBean.init()方法内部会调用其自定义的initServletBean()方法，但该方法实际上是由FrameworkServlet实现，实际上是执行了FrameworkServlet.initServletBean()方法。
FrameworkServlet.initServletBean()方法内部真正初始化了applicationContext，并加载配置文件，最终调用其自定义的initFrameworkServlet()方法。

@Override
public final void init() throws ServletException {

  // Set bean properties from init parameters.
  PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
  if (!pvs.isEmpty()) {
    try {
      BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
      ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
      bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
      initBeanWrapper(bw);
      bw.setPropertyValues(pvs, true);
    }
    catch (BeansException ex) {
      if (logger.isErrorEnabled()) {
        logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
      }
      throw ex;
    }
  }

  // Let subclasses do whatever initialization they like.
  initServletBean();
}

我们继续看下FrameworkServlet的initServletBean方法。

核心代码只有两句，在servlet 属性被赋值后调用，初始化servlet容器也就是springmvc的容器(本文这里不是springboot环境，关于springboot环境下容器参考博文Spring、SpringMVC和SpringBoot框架中那些容器)。

initFrameworkServlet是个空方法，没有实现，这里核心就是initWebApplicationContext方法。

@Override
protected final void initServletBean() throws ServletException {
   // 比如Initializing Spring DispatcherServlet 'DispatcherServlet'
   getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
   if (logger.isInfoEnabled()) {
      logger.info("Initializing Servlet '" + getServletName() + "'");
   }
   long startTime = System.currentTimeMillis();

   try {
      this.webApplicationContext = initWebApplicationContext();
      initFrameworkServlet();
   }
   //...
}

③ 内部类ContextRefreshListener

如下所示其实现了ApplicationListener接口，对ContextRefreshedEvent事件感兴趣。也就是说如果应用广播了ContextRefreshedEvent事件，那么其方法FrameworkServlet.this.onApplicationEvent(event);将会被调用。

private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {

  @Override
  public void onApplicationEvent(ContextRefreshedEvent event) {
    FrameworkServlet.this.onApplicationEvent(event);
  }
}

那么流程就很清晰了，当ContextRefreshedEvent事件被广播出来时就会调用这里onApplicationEvent方法，继而触发onRefresh(event.getApplicationContext());–initStrategies(context);进行基础策略对象的实例化。

public void onApplicationEvent(ContextRefreshedEvent event) {
  this.refreshEventReceived = true;
  synchronized (this.onRefreshMonitor) {
    onRefresh(event.getApplicationContext());
  }
}

@Override
protected void onRefresh(ApplicationContext context) {
  initStrategies(context);
}

protected void initStrategies(ApplicationContext context) {
  initMultipartResolver(context);
  initLocaleResolver(context);
  initThemeResolver(context);
  initHandlerMappings(context);
  initHandlerAdapters(context);
  initHandlerExceptionResolvers(context);
  initRequestToViewNameTranslator(context);
  initViewResolvers(context);
  initFlashMapManager(context);
}

ContextRefreshedEvent 事件是上下文刷新事件，该事件是在容器初始化过程中被广播出来的，下面我们分析这个容器初始化过程。

【2】容器初始化

① initWebApplicationContext

initWebApplicationContext将会初始化容器并将容器发布到servletContext中，作为其一个属性。这里首先会尝试获取rootContext (SSM环境下指的是spring容器)，作为springMVC容器的parent。

该方法不会创建springMVC容器，而是委派给createWebApplicationContext创建。

protected WebApplicationContext initWebApplicationContext() {
// 获取rootContext将会作为springmvc容器的parent
  WebApplicationContext rootContext =
      WebApplicationContextUtils.getWebApplicationContext(getServletContext());
  WebApplicationContext wac = null;

// 如果构造函数注入了webApplicationContext ，那么将会作为springMVC容器
  if (this.webApplicationContext != null) {
    // A context instance was injected at construction time -> use it
    wac = this.webApplicationContext;
// 如果是ConfigurableWebApplicationContext类型，且容器未激活，
//则尝试设置父类然后配置、刷新容器
    if (wac instanceof ConfigurableWebApplicationContext) {
      ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
      if (!cwac.isActive()) {
        // The context has not yet been refreshed -> provide services such as
        // setting the parent context, setting the application context id, etc
        if (cwac.getParent() == null) {
          // The context instance was injected without an explicit parent -> set
          // the root application context (if any; may be null) as the parent
          cwac.setParent(rootContext);
        }
        configureAndRefreshWebApplicationContext(cwac);
      }
    }
  }
  // 尝试从servlet context寻找容器，
  //如果找到就认为该容器已经设置了parent并配置、刷新过
  if (wac == null) {
    // No context instance was injected at construction time -> see if one
    // has been registered in the servlet context. If one exists, it is assumed
    // that the parent context (if any) has already been set and that the
    // user has performed any initialization such as setting the context id
    wac = findWebApplicationContext();
  }
  // 实际创建容器的方法
  if (wac == null) {
    // No context instance is defined for this servlet -> create a local one
    wac = createWebApplicationContext(rootContext);
  }
// 如果refreshEventReceived为false，也就是没有刷新过，那么手动调用onRefresh进行刷新
  if (!this.refreshEventReceived) {
    // Either the context is not a ConfigurableApplicationContext with refresh
    // support or the context injected at construction time had already been
    // refreshed -> trigger initial onRefresh manually here.
    synchronized (this.onRefreshMonitor) {
      onRefresh(wac);
    }
  }
// 作为servletContext属性将自身放入
  if (this.publishContext) {
    // Publish the context as a servlet context attribute.
//org.springframework.web.servlet.FrameworkServlet.CONTEXT.DispatcherServlet  
// DispatcherServlet 是本文这里配置的servlet nam      
    String attrName = getServletContextAttributeName();
    getServletContext().setAttribute(attrName, wac);
  }

  return wac;
}

代码解释如下：

① 根据属性ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE(WebApplicationContext.class.getName() + ".ROOT")尝试获取rootContext，其将作为springMVC容器的parent；
② 如果当前对象的webApplicationContext不为null，也就是说实例化时通过有参构造函数注入了webApplicationContext，那么其将作为springMVC容器；

③ 如果容器是ConfigurableWebApplicationContext类型，其未激活，那么尝试设置parent，并调用configureAndRefreshWebApplicationContext进行配置、刷新。

④ 如果容器未null，那么尝试根据其成员变量contextAttribute的值作为属性从ServletContext中获取；默认contextAttribute为null。
⑤ 如果wac为null，也就是springmvc此时仍旧为null，那么调用createWebApplicationContext方法进行创建；
⑥ 如果没有执行过刷新，也就是refreshEventReceived为false，那么这里加锁调用onRefresh方法。在起onApplicationEvent方法中，该属性将会变为true。
⑦ 如果publishContext为true，那么将当前容器发布到ServletContext中作为其属性。属性key为：FrameworkServlet.class.getName() + ".CONTEXT."+serveletName

这里的核心方法是：createWebApplicationContext和configureAndRefreshWebApplicationContext。前者进行创建，后置进行配置、刷新、发布事件等等操作。

② createWebApplicationContext

我们继续看下FrameworkServlet的createWebApplicationContext方法。

protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
// 获取class，本文这里默认是XmlWebApplicationContext
  Class<?> contextClass = getContextClass();
  if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
    throw new ApplicationContextException(
        "Fatal initialization error in servlet with name '" + getServletName() +
        "': custom WebApplicationContext class [" + contextClass.getName() +
        "] is not of type ConfigurableWebApplicationContext");
  }
  // 实例化
  ConfigurableWebApplicationContext wac =
      (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
  // 设置environment
  wac.setEnvironment(getEnvironment());
  // 设置parent
  wac.setParent(parent);
  // 设置配置文件路径
  String configLocation = getContextConfigLocation();
  if (configLocation != null) {
    wac.setConfigLocation(configLocation);
  }
  // 关键核心步骤
  configureAndRefreshWebApplicationContext(wac);

  return wac;
}

代码逻辑很清晰，获取contextClass，然后进行实例化、设置environment、parent、configLocation等，最后调用configureAndRefreshWebApplicationContext对容器进行配置并刷新。

分析到这里，还没有看到诸如viewResolvers、handlerExceptionResolvers等被实例化的影子，那么肯定就在configureAndRefreshWebApplicationContext方法里面了。

③ configureAndRefreshWebApplicationContext

这里配置的servlet-name是DispatcherServlet。

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
  if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
    // The application context id is still set to its original default value
    // -> assign a more useful id based on available information
    if (this.contextId != null) {
      wac.setId(this.contextId);
    }
    else {
      // Generate default id...
      wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
          ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
    }
  }
  // 设置web 上下文--这是Tomcat的哦
  wac.setServletContext(getServletContext());
  // 设置上下文配置
  wac.setServletConfig(getServletConfig());
  // 设置namespace 比如getServletName() + DEFAULT_NAMESPACE_SUFFIX
  wac.setNamespace(getNamespace());
// 添加上下文刷新监听器，ContextRefreshListener对ContextRefreshedEvent事件感兴趣
  wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

  // The wac environment's #initPropertySources will be called in any case when the context
  // is refreshed; do it eagerly here to ensure servlet property sources are in place for
  // use in any post-processing or initialization that occurs below prior to #refresh
  ConfigurableEnvironment env = wac.getEnvironment();
  if (env instanceof ConfigurableWebEnvironment) {
  // 设置ServletContextPropertySource ServletConfigPropertySource
    ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
  }
  // 容器的后置处理
  postProcessWebApplicationContext(wac);
  // 将容器交给ApplicationContextInitializer
  applyInitializers(wac);
  // 刷新容器
  wac.refresh();
}

方法逻辑解释如下：

① 设置id,如org.springframework.web.context.WebApplicationContext:/DispatcherServlet；
② 设置servletContext引用，这是属于web server的根容器，这里是Tomcat的容器；
③ 设置servletConfig
④ 设置namespace 比如getServletName() + DEFAULT_NAMESPACE_SUFFIX
⑤ 添加上下文刷新监听器，ContextRefreshListener对ContextRefreshedEvent事件感兴趣；
⑥ 获取ConfigurableEnvironment ，并设置ServletContextPropertySource 、ServletConfigPropertySource
⑦postProcessWebApplicationContext对容器进行后置处理，该方法默认为空，没有实现。容器的修操作交给ApplicationContextInitializer。
⑧applyInitializers将容器交给一系列ApplicationContextInitializer初始化器
⑨ wac.refresh()刷新容器

④ refresh刷新容器

AbstractApplicationContext的refresh是个典型的模板方法，由众多核心方法组成。

@Override
public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
    StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

    // Prepare this context for refreshing.
    prepareRefresh();

    // Tell the subclass to refresh the internal bean factory.
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    // Prepare the bean factory for use in this context.
    prepareBeanFactory(beanFactory);

    try {
      // Allows post-processing of the bean factory in context subclasses.
      postProcessBeanFactory(beanFactory);

      StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
      // Invoke factory processors registered as beans in the context.
      invokeBeanFactoryPostProcessors(beanFactory);

      // Register bean processors that intercept bean creation.
      registerBeanPostProcessors(beanFactory);
      beanPostProcess.end();

      // Initialize message source for this context.
      initMessageSource();

      // Initialize event multicaster for this context.
      initApplicationEventMulticaster();

      // Initialize other special beans in specific context subclasses.
      onRefresh();

      // Check for listener beans and register them.
      registerListeners();

      // Instantiate all remaining (non-lazy-init) singletons.
      finishBeanFactoryInitialization(beanFactory);

      // Last step: publish corresponding event.
      finishRefresh();
    }

    catch (BeansException ex) {
      if (logger.isWarnEnabled()) {
        logger.warn("Exception encountered during context initialization - " +
            "cancelling refresh attempt: " + ex);
      }

      // Destroy already created singletons to avoid dangling resources.
      destroyBeans();

      // Reset 'active' flag.
      cancelRefresh(ex);

      // Propagate exception to caller.
      throw ex;
    }

    finally {
      // Reset common introspection caches in Spring's core, since we
      // might not ever need metadata for singleton beans anymore...
      resetCommonCaches();
      contextRefresh.end();
    }
  }
}

本文这里我们不关心每一个方法，我们只看initApplicationEventMulticaster(初始化广播器)、registerListeners();(注册监听器)以及finishRefresh(发布事件)。其他方法我们留在分析spring容器初始化过程时展开。

在前面Spring中事件监听(通知)机制详解与实践一文中我们详细分析了事件广播机制与监听器、广播器的注册。这里我们不再赘述直接看finishRefresh();方法。

如下所示在publishEvent(new ContextRefreshedEvent(this));会广播事件ContextRefreshedEvent给所有的监听器。那么FrameworkServlet的内部类ContextRefreshListener的onApplicationEvent方法将会被触发。

protected void finishRefresh() {
  // Clear context-level resource caches (such as ASM metadata from scanning).
  clearResourceCaches();

  // Initialize lifecycle processor for this context.
  initLifecycleProcessor();

  // Propagate refresh to lifecycle processor first.
  getLifecycleProcessor().onRefresh();

  // Publish the final event.
  publishEvent(new ContextRefreshedEvent(this));

  // Participate in LiveBeansView MBean, if active.
  if (!IN_NATIVE_IMAGE) {
    LiveBeansView.registerApplicationContext(this);
  }
}

【3】策略对象初始化

当事件ContextRefreshedEvent被广播出来时，最终会触发下面initStrategies方法进行策略对象的初始化。

protected void initStrategies(ApplicationContext context) {
  initMultipartResolver(context);
  initLocaleResolver(context);
  initThemeResolver(context);
  initHandlerMappings(context);
  initHandlerAdapters(context);
  initHandlerExceptionResolvers(context);
  initRequestToViewNameTranslator(context);
  initViewResolvers(context);
  initFlashMapManager(context);
}

方法解释如下所示：

① 初始化MultipartResolver，主要用来处理文件上传；
② 初始化区域解析器，主要用来解析区域信息应用于国际化场景；
③ 初始化主题解析器，默认是FixedThemeResolver；
④ 初始化处理器映射器，这个很关键哦；
⑤ 初始化处理器适配器，这个很关键哦；
⑥ 初始化异常解析器，这个很关键哦；
⑦ 初始化请求视图名称转换器，默认是DefalutRequestToViewNameTranslator；
⑧ 初始化视图解析器；
⑨ 初始化闪存属性管理器。

关于闪存属性管理器可以参考SpringMVC中重定向请求时传输参数原理分析与实践

关于处理器适配器可以参考：SpringMVC常见组件之HandlerAdapter分析

关于处理器映射器可以参考：SpringMVC常见组件之HandlerMapping分析

关于参数解析器可以参考：SpringMVC常见组件之HandlerMethodArgumentResolver解析

关于返回结果处理器可以参考：SpringMVC常见组件HandlerMethodReturnValueHandler解析

关于数据绑定与格式化转换可以参考：SpringMVC常见组件之DataBinder数据绑定器分析

关于视图解析器可以参考：SpringMVC常见组件之ViewResolver分析

关于异常解析器可以参考：SpringMVC常见组件之HandlerExceptionResolver分析

下面我们见到看下这九个方法。

① initMultipartResolver

这里MULTIPART_RESOLVER_BEAN_NAME=multipartResolver，默认将会获取得到一个CommonsMultipartResolver实例。如果实例化失败，将会抛出NoSuchBeanDefinitionException异常。

private void initMultipartResolver(ApplicationContext context) {
  try {
    this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
    //...
  }
}

SpringMVC源码分析之策略对象初始化_初始化_02

② initLocaleResolver

这里LOCALE_RESOLVER_BEAN_NAME=localeResolver，默认将会获取得到一个AcceptHeaderLocaleResolver实例。如果实例化失败，将会抛出NoSuchBeanDefinitionException异常。

private void initLocaleResolver(ApplicationContext context) {
  try {
    this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
 //...
  }
}

③ initThemeResolver

这里THEME_RESOLVER_BEAN_NAME=themeResolver，默认将会获取得到一个FixedThemeResolver实例。如果实例化失败，将会抛出NoSuchBeanDefinitionException异常。

private void initThemeResolver(ApplicationContext context) {
  try {
    this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
    //...
  }
}

④ initHandlerMappings

private void initHandlerMappings(ApplicationContext context) {
  this.handlerMappings = null;
  // 是否检测所有handlermappings? 默认true
  if (this.detectAllHandlerMappings) {
// 从容器中获取所有的HandlerMapping，如viewControllerHandlerMapping
    Map<String, HandlerMapping> matchingBeans =
        BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
    if (!matchingBeans.isEmpty()) {
      this.handlerMappings = new ArrayList<>(matchingBeans.values());
      // 对handlerMappings 按照order值 进行排序
      AnnotationAwareOrderComparator.sort(this.handlerMappings);
    }
  }
  else {
    try {
    // 获取一个bean name为handlerMapping的实例
    // HANDLER_MAPPING_BEAN_NAME = "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.
    }
  }

// 如果handlerMappings  仍旧为null，则从默认策略配置中获取
  if (this.handlerMappings == null) {
// 尝试从DispatcherServlet.properties获取HandlerMapping对应的value，进行实例化
    this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
    if (logger.isTraceEnabled()) {
      logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
          "': using default strategies from DispatcherServlet.properties");
    }
  }
// 遍历处理HandlerMapping 
  for (HandlerMapping mapping : this.handlerMappings) {
  // 判断当前handlermapping的patternParser是否为null
    if (mapping.usesPathPatterns()) {
      this.parseRequestPath = true;
      break;
    }
  }
}

Spring 5带来 PathPatternParser，用于解析URI模板模式。PathPatternParser将路径分成PathElements的链接列表。这一链条PathElements采取的是PathPattern的模式快速匹配的类。

AnnotationAwareOrderComparator.sort(this.handlerMappings);表示根据handlermapping的order属性值进行排序。排序前：
SpringMVC源码分析之策略对象初始化_初始化_03
其中beanName为viewControllerHandlerMapping对应的实际bean是SimpleUrlHandlerMapping,通常由 <mvc:view-controller path="/" view-name="index"></mvc:view-controller>配置生成。
SpringMVC源码分析之策略对象初始化_初始化_04

排序后：
SpringMVC源码分析之策略对象初始化_初始化_05
最后一个SimpleUrlHandlerMapping则是默认拦截所有然后交给springmvc的默认处理器。
SpringMVC源码分析之策略对象初始化_mvc_06

⑤ initHandlerAdapters

initHandlerAdaptersd的过程与initHandlerMappings过程一致：

① 检测容器中所有的HandlerAdapter，得到实例并排序；
② 如果①没有得到，则尝试获取一个beanName为handlerAdapter的实例；
③ 如果②仍旧没有得到，则使用默认策略获取HandlerAdapter

private void initHandlerAdapters(ApplicationContext context) {
  this.handlerAdapters = null;

  if (this.detectAllHandlerAdapters) {
    // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
    Map<String, HandlerAdapter> matchingBeans =
        BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
    if (!matchingBeans.isEmpty()) {
      this.handlerAdapters = new ArrayList<>(matchingBeans.values());
      // We keep HandlerAdapters in sorted order.
      AnnotationAwareOrderComparator.sort(this.handlerAdapters);
    }
  }
  else {
    try {
      HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
      this.handlerAdapters = Collections.singletonList(ha);
    }
    catch (NoSuchBeanDefinitionException ex) {
      // Ignore, we'll add a default HandlerAdapter later.
    }
  }

// 使用默认策略获取handlerAdapters 
  if (this.handlerAdapters == null) {
    this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
    if (logger.isTraceEnabled()) {
      logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +
          "': using default strategies from DispatcherServlet.properties");
    }
  }
}

如下所示是得到的HandlerAdapter(排序后的)：
SpringMVC源码分析之策略对象初始化_初始化_07

⑥ initHandlerExceptionResolvers

initHandlerExceptionResolvers的过程与initHandlerMappings过程一致：

① 检测容器中所有的HandlerExceptionResolver，得到实例并排序；
② 如果①没有得到，则尝试获取一个beanName为handlerExceptionResolver的实例；
③ 如果②仍旧没有得到，则使用默认策略获取handlerExceptionResolvers

private void initHandlerExceptionResolvers(ApplicationContext context) {
  this.handlerExceptionResolvers = null;

  if (this.detectAllHandlerExceptionResolvers) {
    // Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
    Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
        .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
    if (!matchingBeans.isEmpty()) {
      this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
      // We keep HandlerExceptionResolvers in sorted order.
      AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
    }
  }
  else {
    try {
      HandlerExceptionResolver her =
          context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
      this.handlerExceptionResolvers = Collections.singletonList(her);
    }
    catch (NoSuchBeanDefinitionException ex) {
      // Ignore, no HandlerExceptionResolver is fine too.
    }
  }

  // Ensure we have at least some HandlerExceptionResolvers, by registering
  // default HandlerExceptionResolvers if no other resolvers are found.
  if (this.handlerExceptionResolvers == null) {
    this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
    if (logger.isTraceEnabled()) {
      logger.trace("No HandlerExceptionResolvers declared in servlet '" + getServletName() +
          "': using default strategies from DispatcherServlet.properties");
    }
  }
}

⑦ initRequestToViewNameTranslator

如下所示，从容器中获取一个beanName为viewNameTranslator的实例。这里得到的是DefaultRequestToViewNameTranslator。

private void initRequestToViewNameTranslator(ApplicationContext context) {
  try {
    this.viewNameTranslator =
        context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
    //...
  }
}

SpringMVC源码分析之策略对象初始化_mvc_08

⑧ initViewResolvers

initViewResolvers的过程与initHandlerMappings过程一致：

① 检测容器中所有的s，得到实例并排序；
② 如果①没有得到，则尝试获取一个beanName为viewResolver的实例；
③ 如果②仍旧没有得到，则使用默认策略获取viewResolvers

private void initViewResolvers(ApplicationContext context) {
  this.viewResolvers = null;

  if (this.detectAllViewResolvers) {
    // Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
    Map<String, ViewResolver> matchingBeans =
        BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
    if (!matchingBeans.isEmpty()) {
      this.viewResolvers = new ArrayList<>(matchingBeans.values());
      // We keep ViewResolvers in sorted order.
      AnnotationAwareOrderComparator.sort(this.viewResolvers);
    }
  }
  else {
    try {
      ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
      this.viewResolvers = Collections.singletonList(vr);
    }
    catch (NoSuchBeanDefinitionException ex) {
      // Ignore, we'll add a default ViewResolver later.
    }
  }

  // Ensure we have at least one ViewResolver, by registering
  // a default ViewResolver if no other resolvers are found.
  if (this.viewResolvers == null) {
    this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
    if (logger.isTraceEnabled()) {
      logger.trace("No ViewResolvers declared for servlet '" + getServletName() +
          "': using default strategies from DispatcherServlet.properties");
    }
  }
}

⑨ initFlashMapManager

如下所示，从容器中获取一个beanName为flashMapManagerd的实例。这里默认得到一个SessionFlashMapManager。SessionFlashMapManager提供了在session中检索和更新flashMap的方法。

private void initFlashMapManager(ApplicationContext context) {
  try {
    this.flashMapManager = context.getBean(FLASH_MAP_MANAGER_BEAN_NAME, FlashMapManager.class);
  //...
  }
}

SpringMVC源码分析之策略对象初始化_springmvc初始化_09

⑩ getDefaultStrategies

在spring-webmvc包中默认配置了DispatcherServlet.properties，用以在获取不到策略接口的情况下，实例化一个默认值。

//路径
org\springframework\spring-webmvc\5.3.1\spring-webmvc-5.3.1.jar!\org\springframework\web\servlet\DispatcherServlet.properties

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
  org.springframework.web.servlet.function.support.RouterFunctionMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
  org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
  org.springframework.web.servlet.function.support.HandlerFunctionAdapter


org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
  org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
  org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

springmvc会根据入参中的Class<T> strategyInterface名称作为key获取对应的value，然后遍历实例化并放到List返回。

protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
  if (defaultStrategies == null) {
    try {
      // Load default strategy implementations from properties file.
      // This is currently strictly internal and not meant to be customized
      // by application developers.
      ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
      defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
    }
    catch (IOException ex) {
      throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
    }
  }

  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 Collections.emptyList();
  }
}