public interface ServletContextListener extends EventListener {
    public void contextInitialized(ServletContextEvent sce);

    public void contextDestroyed(ServletContextEvent sce);
}

public void contextInitialized(ServletContextEvent event) {
   // 初始化ROOT web应用上下文
   initWebApplicationContext(event.getServletContext());
}

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
   // web.xml中只允许存在一个ContextLoader类或其子类的对象
   if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
      throw new IllegalStateException(
            "Cannot initialize context because there is already a root application context present - " +
            "check whether you have multiple ContextLoader* definitions in your web.xml!");
   }

   servletContext.log("Initializing Spring root WebApplicationContext");
   Log logger = LogFactory.getLog(ContextLoader.class);
   if (logger.isInfoEnabled()) {
      logger.info("Root WebApplicationContext: initialization started");
   }
   long startTime = System.currentTimeMillis();

   try {
      if (this.context == null) {
         // 不存在，则创建ROOT web应用上下文
         this.context = createWebApplicationContext(servletContext); 
      }
      if (this.context instanceof ConfigurableWebApplicationContext) { // true
         ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
         if (!cwac.isActive()) { // 是否已refresh，且未关闭 false
            if (cwac.getParent() == null) {
               // 加载ROOT web应用上下文的parent
               ApplicationContext parent = loadParentContext(servletContext); 
               cwac.setParent(parent);
            }
            // 配置并刷新整个根IoC容器，在这里会进行Bean的创建和初始化
            configureAndRefreshWebApplicationContext(cwac, servletContext);
         }
      }
      // 将ROOT Web应用上下文引用保存到ServletContext
    servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

      ClassLoader ccl = Thread.currentThread().getContextClassLoader();
      if (ccl == ContextLoader.class.getClassLoader()) {
         currentContext = this.context;
      }
      else if (ccl != null) {
         currentContextPerThread.put(ccl, this.context);
      }

      if (logger.isInfoEnabled()) {
         long elapsedTime = System.currentTimeMillis() - startTime;
         logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
      }

      return this.context;
   }
   catch (RuntimeException | Error ex) {
      logger.error("Context initialization failed", ex);
      servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
      throw ex;
   }
}

// 配置并刷新上下文，进行Bean的创建和初始化
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
   if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
      String idParam = sc.getInitParameter(CONTEXT_ID_PARAM); // 自定义contextId
      if (idParam != null) {
         wac.setId(idParam);
      }
      else {
         // Generate default id... 默认的context id
         wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
               ObjectUtils.getDisplayString(sc.getContextPath()));
      }
   }

   wac.setServletContext(sc);
   // CONFIG_LOCATION_PARAM = "contextConfigLocation"，xml配置文件路径
   // 获取web.xml中<context-param>标签配置的全局变量，其中key为CONFIG_LOCATION_PARAM，
   // 也就是配置的相应Bean的xml文件名，并将其设置到WebApplicationContext中。
   String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
   if (configLocationParam != null) {
      wac.setConfigLocation(configLocationParam); // 设置配置文件路径
   }

   ConfigurableEnvironment env = wac.getEnvironment();
   if (env instanceof ConfigurableWebEnvironment) {
      // 替换占位符属性源为实际的属性源
      ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
   }

   // 自定义上下文，获取所有初始化器ApplicationContextInitializer，并回调initialize方法
   customizeContext(sc, wac);
   wac.refresh(); // 刷新上下文
}

protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
   List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
         determineContextInitializerClasses(sc); // 获取应用上下文初始化器类列表

   for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
      // 解析上下文类
      Class<?> initializerContextClass =
            GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
      if (initializerContextClass != null && !initializerContextClass.isInstance(wac)) {
         throw new ApplicationContextException(String.format(
               "Could not apply context initializer [%s] since its generic parameter [%s] " +
               "is not assignable from the type of application context used by this " +
               "context loader: [%s]", initializerClass.getName(), initializerContextClass.getName(),
               wac.getClass().getName()));
      }
      this.contextInitializers.add(BeanUtils.instantiateClass(initializerClass)); // 实例化初始化器
   }

   AnnotationAwareOrderComparator.sort(this.contextInitializers); // 排序
   for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
      initializer.initialize(wac); // 调用初始化器的initialize方法
   }
}

initializer.initialize(wac);

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

   try {
      // 初始化DispatcherServlet web应用上下文
      this.webApplicationContext = initWebApplicationContext(); 
      initFrameworkServlet(); // 空方法
   }
   catch (ServletException | RuntimeException ex) {
      logger.error("Context initialization failed", ex);
      throw ex;
   }

   if (logger.isDebugEnabled()) {
      String value = this.enableLoggingRequestDetails ?
            "shown which may lead to unsafe logging of potentially sensitive data" :
            "masked to prevent unsafe logging of potentially sensitive data";
      logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
            "': request parameters and headers will be " + value);
   }

   if (logger.isInfoEnabled()) {
      logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
   }
}

protected WebApplicationContext initWebApplicationContext() {
   // 获取由ContextLoaderListener创建的ROOT Web应用上下文
   WebApplicationContext rootContext =
         WebApplicationContextUtils.getWebApplicationContext(getServletContext());
   WebApplicationContext wac = null;

   if (this.webApplicationContext != null) { // 如果通过构造器注入了上下文，则直接使用
      // A context instance was injected at construction time -> use it
      wac = this.webApplicationContext;
      if (wac instanceof ConfigurableWebApplicationContext) {
         ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
         if (!cwac.isActive()) { // 如果未刷新，则刷新上下文
            if (cwac.getParent() == null) {
               cwac.setParent(rootContext); // 设置父上下文
            }
            // 配置并刷新Web上下文，初始化Bean
            configureAndRefreshWebApplicationContext(cwac);
         }
      }
   }
   if (wac == null) {
      wac = findWebApplicationContext(); // 从servlet context查找是否有初始化完成的web应用上下文
   }
   if (wac == null) {
      wac = createWebApplicationContext(rootContext); // 还是没有，则创建一个web应用上下文
   }

   // 这里refreshEventReceived为true，onApplicationEvent(ContextRefreshedEvent)
   // 在上下文初始化完成后已将refreshEventReceived置为true
   if (!this.refreshEventReceived) {
      synchronized (this.onRefreshMonitor) {
         onRefresh(wac);
      }
   }

   if (this.publishContext) {
      // Publish the context as a servlet context attribute.
      String attrName = getServletContextAttributeName();
      // 将当前web应用上下文的引用设置到servlet context
      getServletContext().setAttribute(attrName, wac); 
   }

   return wac;
}

// applicationContext1.xml文件中配置一个id为baseBean的Bean
ApplicationContext baseContext = new ClassPathXmlApplicationContext("applicationContext1.xml");

Object obj1 = baseContext.getBean("baseBean");

System.out.println("baseContext Get Bean " + obj1);

// applicationContext2.xml文件中配置一个id未subBean的Bean
ApplicationContext subContext = new ClassPathXmlApplicationContext(new String[]{"applicationContext2.xml"}, baseContext);

Object obj2 = subContext.getBean("baseBean");

System.out.println("subContext get baseContext Bean " + obj2);

Object obj3 = subContext.getBean("subBean");

System.out.println("subContext get subContext Bean " + obj3);

// 抛出NoSuchBeanDefinitionException异常
Object obj4 = baseContext.getBean("subBean");

System.out.println("baseContext get subContext Bean " + obj4);

protected WebApplicationContext createWebApplicationContext(@Nullable WebApplicationContext parent) {
   return createWebApplicationContext((ApplicationContext) parent);
}

protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
	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); // 实例化

	// 设置环境、父上下文、配置文件路径
	wac.setEnvironment(getEnvironment());
	wac.setParent(parent);
	String configLocation = getContextConfigLocation();
	if (configLocation != null) {
		wac.setConfigLocation(configLocation);
	}
	configureAndRefreshWebApplicationContext(wac); // 配置并刷新Web应用上下文

	return wac;
}

// 配置并刷新Web应用上下文
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
	if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
		if (this.contextId != null) {
			wac.setId(this.contextId); // 设置自定义的id
		}
		else {
			// Generate default id... 使用默认的id
			wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
					ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
		}
	}

	wac.setServletContext(getServletContext()); // 设置ServletContext、ServletConfig、Namespace
	wac.setServletConfig(getServletConfig());
	wac.setNamespace(getNamespace());
	// 添加事件监听器，只处理该web应用上下文发出的事件
	wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

	ConfigurableEnvironment env = wac.getEnvironment();
	if (env instanceof ConfigurableWebEnvironment) {
		// 初始化属性源ServletContext、ServletConfig，替换servlet占位符属性源
		((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
	}

	postProcessWebApplicationContext(wac); // 后处理web上下文
	applyInitializers(wac); // 应用初始化器到上下文
	wac.refresh(); // 刷新上下文
}

private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {

   @Override
   public void onApplicationEvent(ContextRefreshedEvent event) {
      // 调用FrameworkServlet.onApplicationEvent方法
      FrameworkServlet.this.onApplicationEvent(event);
   }
}

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

protected void applyInitializers(ConfigurableApplicationContext wac) {
   // 全局初始化器类名
   String globalClassNames = getServletContext().getInitParameter(ContextLoader.GLOBAL_INITIALIZER_CLASSES_PARAM);
   if (globalClassNames != null) {
      for (String className : StringUtils.tokenizeToStringArray(globalClassNames, INIT_PARAM_DELIMITERS)) {
         this.contextInitializers.add(loadInitializer(className, wac)); // 实例化初始化器
      }
   }

   if (this.contextInitializerClasses != null) {
      for (String className : StringUtils.tokenizeToStringArray(this.contextInitializerClasses, INIT_PARAM_DELIMITERS)) {
         this.contextInitializers.add(loadInitializer(className, wac));
      }
   }

   AnnotationAwareOrderComparator.sort(this.contextInitializers);// 排序
   for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
      initializer.initialize(wac); // 回调initialize方法
   }
}

// context为DispatcherServlet创建的一个IoC子容器 WebApplicationContext
protected void onRefresh(ApplicationContext context) { 
   initStrategies(context);
}

protected void initStrategies(ApplicationContext context) { 
   initMultipartResolver(context); // 初始化文件上传解析器
   initLocaleResolver(context); // 初始化LocaleResolver(AcceptHeaderLocaleResolver)
   initThemeResolver(context); // 初始化ThemeResolver(FixedThemeResolver)
   initHandlerMappings(context); // 初始化BeanNameUrlHandlerMapping, RequestMappingHandlerMapping
   initHandlerAdapters(context); // 初始化HandlerAdapter
   initHandlerExceptionResolvers(context); // 初始化HandlerExceptionResolver
   initRequestToViewNameTranslator(context);
   initViewResolvers(context); // 初始化ViewResolver
   initFlashMapManager(context);
}

private void initHandlerMappings(ApplicationContext context) {
   this.handlerMappings = null;

   // 是否检测出所有的HandlerMapping Bean，还是只检测name为handlerMapping的HandlerMapping Bean
   if (this.detectAllHandlerMappings) {
      // 找出所有的HandlerMapping Bean，包括父BeanFactory中的定义
      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 {
         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.
      }
   }

   // 默认是BeanNameUrlHandlerMapping, RequestMappingHandlerMapping(这里！！！)
   if (this.handlerMappings == null) {
      // 初始化BeanNameUrlHandlerMapping, RequestMappingHandlerMapping(初始化时扫描Controller，注册HandlerMethod)
      this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
      if (logger.isTraceEnabled()) {
         logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
               "': using default strategies from DispatcherServlet.properties");
      }
   }
}

// ApplicationObjectSupport类
public final void setApplicationContext(@Nullable ApplicationContext context) throws BeansException {
   if (context == null && !isContextRequired()) {
      // Reset internal context state.
      this.applicationContext = null;
      this.messageSourceAccessor = null;
   }
   else if (this.applicationContext == null) {
      // Initialize with passed-in context.
      if (!requiredContextClass().isInstance(context)) {
         throw new ApplicationContextException(
               "Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
      }
      this.applicationContext = context;
      this.messageSourceAccessor = new MessageSourceAccessor(context);
      initApplicationContext(context); // 初始化
   }
   else {
      // Ignore reinitialization if same context passed in.
      if (this.applicationContext != context) {
         throw new ApplicationContextException(
               "Cannot reinitialize with different application context: current one is [" +
               this.applicationContext + "], passed-in one is [" + context + "]");
      }
   }
}

// WebApplicationObjectSupport类
protected void initApplicationContext(ApplicationContext context) {
	 // ApplicationObjectSupport.initApplicationContext()
   super.initApplicationContext(context); 
   if (this.servletContext == null && context instanceof WebApplicationContext) {
     	// 设置ServletContext
      this.servletContext = ((WebApplicationContext) context).getServletContext();
      if (this.servletContext != null) {
         initServletContext(this.servletContext); // 空方法体
      }
   }
}
// ApplicationObjectSupport类
protected void initApplicationContext(ApplicationContext context) throws BeansException {
	initApplicationContext(); // --> AbstractHandlerMapping类
}
// AbstractHandlerMapping类
protected void initApplicationContext() throws BeansException {
	extendInterceptors(this.interceptors); // 添加自定义的拦截器(空方法)
	detectMappedInterceptors(this.adaptedInterceptors); // 从容器中获取所有MappedInterceptor Bean
	initInterceptors(); // 初始化拦截器，并适配拦截器
}
// AbstractHandlerMapping类
protected void detectMappedInterceptors(List<HandlerInterceptor> mappedInterceptors) {
	mappedInterceptors.addAll(
			BeanFactoryUtils.beansOfTypeIncludingAncestors(
					obtainApplicationContext(), MappedInterceptor.class, true, false).values());
}
// AbstractHandlerMapping类
protected void initInterceptors() {
	if (!this.interceptors.isEmpty()) {
		for (int i = 0; i < this.interceptors.size(); i++) {
			Object interceptor = this.interceptors.get(i);
			if (interceptor == null) {
				throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
			}
			this.adaptedInterceptors.add(adaptInterceptor(interceptor)); // 将拦截器适配成HandlerInterceptor
		}
	}
}

// WebApplicationObjectSupport类
public final void setServletContext(ServletContext servletContext) {
   if (servletContext != this.servletContext) {
      this.servletContext = servletContext; // 设置ServletContext
      initServletContext(servletContext);
   }
}

public void afterPropertiesSet() {
   this.config = new RequestMappingInfo.BuilderConfiguration();
   this.config.setUrlPathHelper(getUrlPathHelper());
   this.config.setPathMatcher(getPathMatcher());
   this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
   this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
   this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
   this.config.setContentNegotiationManager(getContentNegotiationManager());

   super.afterPropertiesSet(); // 扫描bean，注册HandlerMethod
}

// AbstractHandlerMethodMapping类
public void afterPropertiesSet() {
   initHandlerMethods();  // 扫描bean，注册HandlerMethod
}

// AbstractHandlerMethodMapping类
protected void initHandlerMethods() {
   for (String beanName : getCandidateBeanNames()) { // 获取所有的bean names
      if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
         processCandidateBean(beanName);
      }
   }
   handlerMethodsInitialized(getHandlerMethods()); // 日志打印
}

// 确定bean的类型，判断是否是Handler，检测HandlerMethod
protected void processCandidateBean(String beanName) {
   Class<?> beanType = null;
   try {
      beanType = obtainApplicationContext().getType(beanName); // 获取Bean类型
   }
   catch (Throwable ex) {
      // An unresolvable bean type, probably from a lazy bean - let's ignore it. (忽略)
      if (logger.isTraceEnabled()) {
         logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
      }
   }
   // 类上标注@Controller或@RequestMapping注解，即为Handler
   if (beanType != null && isHandler(beanType)) { 
      detectHandlerMethods(beanName); // 检测HandlerMathod并注册
   }
}

protected void detectHandlerMethods(Object handler) {
   Class<?> handlerType = (handler instanceof String ?
         obtainApplicationContext().getType((String) handler) : handler.getClass()); // 获取handler type

   if (handlerType != null) {
      Class<?> userType = ClassUtils.getUserClass(handlerType); // 获取目标类
      Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
            (MethodIntrospector.MetadataLookup<T>) method -> {
               try {
                  return getMappingForMethod(method, userType);
               }
               catch (Throwable ex) {
                  throw new IllegalStateException("Invalid mapping on handler class [" +
                        userType.getName() + "]: " + method, ex);
               }
            });
      if (logger.isTraceEnabled()) {
         logger.trace(formatMappings(userType, methods)); // 格式化输出RequestMappingInfo
      }
      methods.forEach((method, mapping) -> {
         Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
         registerHandlerMethod(handler, invocableMethod, mapping); // 注册HandlerMethod
      });
   }
}

protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
   RequestMappingInfo info = createRequestMappingInfo(method); // 创建RequestMappingInfo
   if (info != null) {
      RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType); // 获取类上的RequestMappingInfo
      if (typeInfo != null) {
         info = typeInfo.combine(info); // 合并类级别和方法级别的RequestMappingInfo
      }
      String prefix = getPathPrefix(handlerType);
      if (prefix != null) {
         info = RequestMappingInfo.paths(prefix).build().combine(info);
      }
   }
   return info;
}
// 基于@RequestMapping注解，创建RequestMappingInfo对象
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
	// 获取@RequestMapping注解
	RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
	RequestCondition<?> condition = (element instanceof Class ?
			getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
	return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
   this.mappingRegistry.register(mapping, handler, method); // 注册HandlerMethod
}

// 注册HandlerMethod
// @param mapping RequestMappingInfo
// @param handler handler beanName(String)
// @param method 处理器方法
public void register(T mapping, Object handler, Method method) {
	this.readWriteLock.writeLock().lock();
	try {
		HandlerMethod handlerMethod = createHandlerMethod(handler, method); // 创建HandlerMethod
		assertUniqueMethodMapping(handlerMethod, mapping); // 确定映射的唯一性
		this.mappingLookup.put(mapping, handlerMethod); // 保存

		List<String> directUrls = getDirectUrls(mapping); // 从RequestMappingInfo获取不需要match的url
		for (String url : directUrls) {
			this.urlLookup.add(url, mapping);
		}

		String name = null;
		if (getNamingStrategy() != null) {
			name = getNamingStrategy().getName(handlerMethod, mapping);
			addMappingName(name, handlerMethod);
		}

		CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
		if (corsConfig != null) {
			this.corsLookup.put(handlerMethod, corsConfig);
		}

		this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
	}
	finally {
		this.readWriteLock.writeLock().unlock();
	}
}

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

   // 是否检测出所有的HandlerAdapter Bean，还是只检测name为handlerAdapter的HandlerAdapter Bean
   if (this.detectAllHandlerAdapters) {
      // 找出所有的HandlerAdapter Bean，包括父BeanFactory中的定义
      Map<String, HandlerAdapter> matchingBeans =
            BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
      if (!matchingBeans.isEmpty()) {
         this.handlerAdapters = new ArrayList<>(matchingBeans.values());
         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.
      }
   }

   // 没有自定义的HandlerAdapter，则使用默认的：HttpRequestHandlerAdapter、
   // SimpleControllerHandlerAdapter、RequestMappingHandlerAdapter（注意这里！！！）
   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");
      }
   }
}

public RequestMappingHandlerAdapter() {
   StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();
   stringHttpMessageConverter.setWriteAcceptCharset(false);  // see SPR-7316

   this.messageConverters = new ArrayList<>(4);
   this.messageConverters.add(new ByteArrayHttpMessageConverter());
   this.messageConverters.add(stringHttpMessageConverter);
   try {
      this.messageConverters.add(new SourceHttpMessageConverter<>());
   }
   catch (Error err) {
      // Ignore when no TransformerFactory implementation is available
   }
   this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());
}

public void afterPropertiesSet() {
   // Do this first, it may add ResponseBody advice beans
   initControllerAdviceCache(); // 初始化ControllerAdvice缓存

   if (this.argumentResolvers == null) {
      List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
      this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
   }
   if (this.initBinderArgumentResolvers == null) {
      List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
      this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
   }
   if (this.returnValueHandlers == null) {
      List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
      this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
   }
}

// 初始化ControllerAdvice缓存
private void initControllerAdviceCache() {
	if (getApplicationContext() == null) {
		return;
	}

	// 找出所有注解了@ControllerAdvice的Bean
	List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
	AnnotationAwareOrderComparator.sort(adviceBeans); // 排序

	List<Object> requestResponseBodyAdviceBeans = new ArrayList<>();

	for (ControllerAdviceBean adviceBean : adviceBeans) { // 遍历
		Class<?> beanType = adviceBean.getBeanType();
		if (beanType == null) {
			throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
		}
		Set<Method> attrMethods = MethodIntrospector.selectMethods(beanType, MODEL_ATTRIBUTE_METHODS);
		if (!attrMethods.isEmpty()) {
			this.modelAttributeAdviceCache.put(adviceBean, attrMethods);
		}
		Set<Method> binderMethods = MethodIntrospector.selectMethods(beanType, INIT_BINDER_METHODS);
		if (!binderMethods.isEmpty()) {
			this.initBinderAdviceCache.put(adviceBean, binderMethods);
		}
		if (RequestBodyAdvice.class.isAssignableFrom(beanType)) {
			requestResponseBodyAdviceBeans.add(adviceBean);
		}
		if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
			requestResponseBodyAdviceBeans.add(adviceBean);
		}
	}

	if (!requestResponseBodyAdviceBeans.isEmpty()) {
		this.requestResponseBodyAdvice.addAll(0, requestResponseBodyAdviceBeans);
	}

	if (logger.isDebugEnabled()) {
		int modelSize = this.modelAttributeAdviceCache.size();
		int binderSize = this.initBinderAdviceCache.size();
		int reqCount = getBodyAdviceCount(RequestBodyAdvice.class);
		int resCount = getBodyAdviceCount(ResponseBodyAdvice.class);
		if (modelSize == 0 && binderSize == 0 && reqCount == 0 && resCount == 0) {
			logger.debug("ControllerAdvice beans: none");
		}
		else {
			logger.debug("ControllerAdvice beans: " + modelSize + " @ModelAttribute, " + binderSize +
					" @InitBinder, " + reqCount + " RequestBodyAdvice, " + resCount + " ResponseBodyAdvice");
		}
	}
}

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.
      }
   }

   // 默认使用InternalResourceViewResolver（注意这里！！！）
   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");
      }
   }
}

public InternalResourceViewResolver() {
   Class<?> viewClass = requiredViewClass(); // 获取视图类InternalResourceView
   if (InternalResourceView.class == viewClass && jstlPresent) {
      viewClass = JstlView.class;
   }
   setViewClass(viewClass); // 设置视图类
}

protected Class<?> requiredViewClass() {
	return InternalResourceView.class;
}