我们都知道BeanFactory 仅提供bean的配置信息加载和创建工作，ApplicationContext 可以理解为是BeanFactory的扩展，ApplicationContext包含了BeanFactory的所有功能，并且对BeanFactory提供了一些企业级的扩展。
AbstractApplicationContext.refresh()方法，是整个ApplicationContext的入口方法，就从这个方法开始探究ApplicationContext容器是怎么刷新的。

  1. public void refresh() throws BeansException, IllegalStateException {
  2.     synchronized (this.startupShutdownMonitor) {
  3.         /**
  4.         * 初始化前的准备工作，例如对系统属性或者环境变量进行准备及验证。
  5.         * 在某种情况下项目的使用需要读取某些系统变量， 而这个变量的设置很可能会影响着系统的正确性
  6.         * 那么ClassPathXmlApplicationContext为我们提供的这个准备函数就显得非常必要
  7.         * 它可以在Spring启动的时候提前对必需的变量进行存在性验证。
  8.         */
  9.         prepareRefresh();
  11.         // Tell the subclass to refresh the internal bean factory.
  12.         // 初始化BeanFactory,并进行XML文件读取。
  13.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  15.         // Prepare the bean factory for use in this context.
  16.         // 对BeanFactory进行各种功能填充。
  17.         // @Qualifier与＠Autowired这两个注解正是在这一步骤中增加的支持。
  18.         prepareBeanFactory(beanFactory);
  20.         try {
  21.             // Allows post-processing of the bean factory in context subclasses.
  22.             /**
  23.             * 子类覆盖方法做额外的处理。
  24.             * 空的函数实现postProcessBeanFactory来方便程序员在业务上做进一步扩展。
  25.             */
  26.             postProcessBeanFactory(beanFactory);
  28.             // 激活各种BeanFactoryPostProcessor后置处理器。（典型的有MyBatis的MapperScannerConfigurer）
  29.             invokeBeanFactoryPostProcessors(beanFactory);
  31.             // 注册BeanPostProcessor，这里只是注册，真正的调用是在getBean时候
  32.             // 注册的定义就是将BeanPostProcessor实例交给BeanFactory管理，放在BeanFactory对象的map属性中
  33.             registerBeanPostProcessors(beanFactory);
  35.             // 为上下文初始化Message资源，即对不同语言的消息体进行国际化处理
  36.             initMessageSource();
  38.             // 初始化事件广播器，广播器的作用是用来存放监听器并在合适的时候调用监听器
  39.             initApplicationEventMulticaster();
  41.             // 空方法，留给子类实现
  42.             onRefresh();
  44.             // 在所有注册的bean中查找listener bean，注册到消息广播器中。
  45.             registerListeners();
  47.             // 初始化剩下的单实例（非惰性的）
  48.             finishBeanFactoryInitialization(beanFactory);
  50.             // Last step: publish corresponding event.
  51.             finishRefresh();
  52.         }
  54.         catch (BeansException ex) {
  55.             if (logger.isWarnEnabled()) {
  56.                 logger.warn("Exception encountered during context initialization - " +
  57.                             "cancelling refresh attempt: " + ex);
  58.             }
  60.             // Destroy already created singletons to avoid dangling resources.
  61.             destroyBeans();
  63.             // Reset 'active' flag.
  64.             cancelRefresh(ex);
  66.             // Propagate exception to caller.
  67.             throw ex;
  68.         }
  70.         finally {
  71.             // Reset common introspection caches in Spring's core, since we
  72.             // might not ever need metadata for singleton beans anymore...
  73.             resetCommonCaches();
  74.         }
  75.     }
  76. }

1. 初始化前准备工作

在容器刷新前的一些初始化准备工作，例如：对系统属性和环境变量的校验工作。

  1. protected void prepareRefresh() {
  2.     // Switch to active.
  3.     this.startupDate = System.currentTimeMillis();
  4.     this.closed.set(false);
  5.     this.active.set(true);
  7.     if (logger.isInfoEnabled()) {
  8.         logger.info("Refreshing " + this);
  9.     }
  11.     // 一个空方法，留给子类实现
  12.     initPropertySources();
  14.     // 验证需要的属性是否已经放入环境中
  15.     getEnvironment().validateRequiredProperties();
  17.     // Store pre-refresh ApplicationListeners...
  18.     if (this.earlyApplicationListeners == null) {
  19.         this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
  20.     }
  21.     else {
  22.         // Reset local application listeners to pre-refresh state.
  23.         this.applicationListeners.clear();
  24.         this.applicationListeners.addAll(this.earlyApplicationListeners);
  25.     }
  27.     // Allow for the collection of early ApplicationEvents,
  28.     // to be published once the multicaster is available...
  29.     this.earlyApplicationEvents = new LinkedHashSet<>();
  30. }

2. 加载BeanFatory

我们知道ApplicationContext容器是具有BeanFactory的功能的，就是在这里实现创建的BeanFactory，创建完后ApplicationContext就真正的具有BeanFactory的功能了。

  1. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  2.     // 由子类实现这个方法
  3.     // 初始化BeanFactory，并读取XML文件，将BeanFactory对象属性放到当前容器中
  4.     // 这里要注意，如果是SpringBoot，子类实现这个方法时，不会加载XML文件，因为加载工作已经在这之前已经被执行
  5.     refreshBeanFactory();
  6.     // 返回ApplicationContext中的beanFactory对象
  7.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  8.     if (logger.isDebugEnabled()) {
  9.         logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
  10.     }
  11.     return beanFactory;
  12. }

SpringBoot 的ApplicationContext容器实现refreshBeanFactory()方法的片段，是没有去创建beanFactory和加载配置的。这里我们有个了解就行，不做详述。我们的重点是分析非SpringBoot的ApplicationContext 实现refreshBeanFactory()方法

  1. protected final void refreshBeanFactory() throws IllegalStateException {
  2.     if (!this.refreshed.compareAndSet(false, true)) {
  3.         throw new IllegalStateException(
  4.             "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
  5.     }
  6.     this.beanFactory.setSerializationId(getId());
  7. }

2.1. 创建BeanFactory

在这里会创建DefaultListableBeanFactory对象，它是BeanFactory的实现。读取XML文件进行解析，对BeanFactory的相关属性赋值

  1. protected final void refreshBeanFactory() throws BeansException {
  2.     if (hasBeanFactory()) {
  3.         destroyBeans();
  4.         closeBeanFactory();
  5.     }
  6.     try {
  7.         // 创建BeanFactory对象
  8.         DefaultListableBeanFactory beanFactory = createBeanFactory();
  9.         // 设置序列号
  10.         beanFactory.setSerializationId(getId());
  11.         // 定制BeanFactory对象属性
  12.         // 其实就是设置allowBeanDefinitionOverriding和allowCircularReferences 属性
  13.         // allowBeanDefinitionOverriding 允许覆盖已经同名bean的实例标识
  14.         // allowCircularReferences 允许解决循环依赖标识
  15.         customizeBeanFactory(beanFactory);
  16.         // 从XML加载bean的配置
  17.         loadBeanDefinitions(beanFactory);
  18.         this.beanFactory = beanFactory;
  19.     }
  20.     catch (IOException ex) {
  21.         throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  22.     }
  23. }

2.1.1. 定制BeanFactory属性

这里只是设置了BeanFactory 工厂对象是否允许覆盖同名的bean和循环依赖

  1. protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
  2.     // 允许覆盖同名的bean
  3.     // false 不允许，true 允许
  4.     if (this.allowBeanDefinitionOverriding != null) {
  5.         beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
  6.     }
  7.     // 允许解决循环依赖
  8.     // false 不允许，true 允许
  9.     if (this.allowCircularReferences != null) {
  10.         beanFactory.setAllowCircularReferences(this.allowCircularReferences);
  11.     }
  12. }

2.1.2. 加载BeanDefinition

通过创建XmlBeanDefinitionReader对象，调用它的loadBeanDefinitions 信息，将bean配置信息转换为BeanDefinition对象，因为XmlBeanDefinitionReader 对象中具有BeanFactory，所以最终会把bean的beanDefinition交给BeanFactory

  1. protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
  2.     // 为BeanFactory工程对象创建XmlBeanDefinitionReader对象
  3.     XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
  5.     beanDefinitionReader.setEnvironment(this.getEnvironment());
  6.     beanDefinitionReader.setResourceLoader(this);
  7.     beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
  9.     initBeanDefinitionReader(beanDefinitionReader);
  10.     // 加载bean配置信息
  11.     loadBeanDefinitions(beanDefinitionReader);
  12. }

3. 准备BeanFactory

前面我们已经创建了BeanFactory对象，并且赋值给了ApplicationContext容器中的beanFactory属性。说明容器已经具备了BeanFactory对象，接下来需要对容器中的BeanFactory对象做一些准备工作

  1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2.     // 设置BeanFactory的classLoader为当前ApplicationContext的classLoader
  3.     beanFactory.setBeanClassLoader(getClassLoader());
  4.     // 为beanFactory中添加表达式语言处理器
  5.     // 处理如：#{bean.xxx}的表达式
  6.     beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  7.     // 为beanFactory中添加propertyEditor
  8.     // 这是一个对bean的属性管理的一个工具类
  9.     // 还可以实现PropertyEditorRegistry 接口，自定义属性管理器然后注册到beanFactory中，具体这里不做详述
  10.     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
  12.     // 为beanFactory添加一个ApplicationContextAwareProcessor后置处理器
  13.     // 这个后置处理器的作用是在执行bean的初始化方法之前，检查bean是否为Aware类型，如果是先执行Aware对应的方法
  14.     beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  16.     // 设置几个需要忽略自动装配的接口，这些接口不会被自动装配
  17.     beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  18.     beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  19.     beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  20.     beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  21.     beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  22.     beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
  24.     // 设置几个自动装配的特殊处理规则
  25.     beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  26.     beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  27.     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  28.     beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  30.     // 为beanFactory中添加一个ApplicationListenerDetector后置处理器
  31.     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
  33.     // 设置对AspectJ的支持
  34.     if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  35.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  36.         // Set a temporary ClassLoader for type matching.
  37.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  38.     }
  40.     // 注册几个默认的bean
  41.     // 这些bean作为单实例bean放入IOC容器中
  42.     // 直接通过getBean(name)的方式就可以获取这些bean
  43.     if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  44.         beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  45.     }
  46.     if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  47.         beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  48.     }
  49.     if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  50.         beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  51.     }
  52. }

4. 处理BeanFactory

这是一个空方法，留给子类实现的。在准备完BeanFactory工厂后，所有bean已经加载但还没实例化前，修改一些BeanDefinition。

  1. protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2. }

5. 注册、激活BeanFactoryPostProcessor

BeanFactoryPostProcessor和BeanPostProcessor 基本类似，只是执行时机不同。BeanFactoryPostProcessor执行时机是在实例化bean前执行（典型有MyBatis的整合，通过MapperScannerConfigurer类来扫描MyBatis的接口和配置）。而BeanPostProcessor执行时机是在创建bean的实例阶段，在Bean的实例创建前后和bean的初始化方法前后做一些扩展。我们知道Spring之所以强大为程序员所追捧，是因为他的扩展性开放性。而PostProcessor就是实现扩展性和开放性的最好体现，程序员只需要实现接口来扩展自己的业务。

  1. protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  2.     PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  4.     // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
  5.     // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  6.     if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  7.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  8.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  9.     }
  10. }

BeanFactoryPostProcessor的注册和激活最终交给PostProcessorRegistrationDelegate来处理。BeanFactoryPostProcessor 后置处理器分为普通的BeanFactoryPostProcessor 后置处理器和BeanDefinitionRegistryPostProcessor 类型的后置处理器。这两个后置处理器的区别在于BeanDefinitionRegistryPostProcessor 多了一个postProcessBeanDefinitionRegistry()后置处理器方法。所以我们在执行后置处理器时，先执行BeanDefinitionRegistryPostProcessor类型postProcessBeanDefinitionRegistry()后置处理器方法，再执行postProcessBeanFactory()共有的后置处理器方法
注册、激活方法的逻辑：

  1. 先执行类型是BeanDefinitionRegistryPostProcessor 类型，且是硬编码的的后置处理器postProcessBeanDefinitionRegistry() 后置处理器方法
  2. 执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor后置处理器的postProcessBeanDefinitionRegistry() 后置处理器方法
  3. 执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor后置处理器的自postProcessBeanDefinitionRegistry() 后置处理器方法
  4. 执行没有实现PriorityOrdered接口和Ordered接口的BeanDefinitionRegistryPostProcessor后置处理器的postProcessBeanDefinitionRegistry() 后置处理器方法
  5. 执行类型是BeanDefinitionRegistryPostProcessor 类型后置处理器的postProcessBeanFactory()后置处理器方法

  6. 执行类型是BeanFactoryPostProcessor类型的后置处理器，按照实现了PriorityOrdered和Ordered 接口的顺序先后执行postProcessBeanFactory() 后置处理器方法，最后再执行没有实现排序接口postProcessBeanFactory() 后置处理器方法。并排除BeanDefinitionRegistryPostProcessor类型，因为这个类型在之前已经执行过。

    1. public static void invokeBeanFactoryPostProcessors(
    2.  ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    4.  // 记录被invoke激活过postProcessBeanDefinitionRegistry()方法的BeanFactoryPostProcessor 后置处理器bean名称
    5.  Set<String> processedBeans = new HashSet<>();
    7.  if (beanFactory instanceof BeanDefinitionRegistry) {
    8.      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    9.      // 常规的BeanFactoryPostProcessor 后置处理器
    10.      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    11.      // 记录BeanDefinitionRegistryPostProcessor 这类特殊类型的后置处理器
    12.      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    13.      // 处理硬编码注册的后置处理器
    14.      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
    15.          if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
    16.              // 处理BeanDefinitionRegistryPostProcessor 这类特殊类型的后置处理器，这类后置处理器比普通后置处理器多了一个postProcessBeanDefinitionRegistry()后置处理器方法
    17.              BeanDefinitionRegistryPostProcessor registryProcessor =
    18.                  (BeanDefinitionRegistryPostProcessor) postProcessor;
    19.              // 执行BeanDefinitionRegistryPostProcessor 这类特殊类型的后置处理器的特殊方法，既：postProcessBeanDefinitionRegistry()
    20.              registryProcessor.postProcessBeanDefinitionRegistry(registry);
    21.              // 记录BeanDefinitionRegistryPostProcessor 这类特殊类型的后置处理器
    22.              registryProcessors.add(registryProcessor);
    23.          }
    24.          else {
    25.              // 记录硬编码注册的常规后置处理器
    26.              regularPostProcessors.add(postProcessor);
    27.          }
    28.      }
    30.      // 通过配置注册的BeanDefinitionRegistryPosProcessor
    31.      List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    33.      // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
    34.      // 获取配置注册的BeanDefinitionRegistryPostProcessor后置处理器
    35.      // 处理实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor后置处理器
    36.      String[] postProcessorNames =
    37.          beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    38.      for (String ppName : postProcessorNames) {
    39.          // 实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor后置处理器
    40.          if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    41.              currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    42.              processedBeans.add(ppName);
    43.          }
    44.      }
    45.      // 对实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor后置处理器进行排序
    46.      sortPostProcessors(currentRegistryProcessors, beanFactory);
    47.      // 记录是BeanDefinitionRegistryPostProcessor 类型的后置处理器，用于在后续统一激活该后置处理器的BeanFactoryPostProcessor的实现方法
    48.      registryProcessors.addAll(currentRegistryProcessors);
    49.      // 执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor后置处理器的自定义方法
    50.      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    51.      currentRegistryProcessors.clear();
    53.      // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
    54.      // 获取配置注册的BeanDefinitionRegistryPostProcessor后置处理器
    55.      // 处理实现了Ordered 接口的BeanDefinitionRegistryPostProcessor后置处理器
    56.      postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    57.      for (String ppName : postProcessorNames) {
    58.          // 实现了Ordered接口的BeanDefinitionRegistryPostProcessor后置处理器
    59.          if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
    60.              currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    61.              processedBeans.add(ppName);
    62.          }
    63.      }
    64.      // 对实现了Ordered接口的BeanDefinitionRegistryPostProcessor后置处理器进行排序
    65.      sortPostProcessors(currentRegistryProcessors, beanFactory);
    66.      // 记录是BeanDefinitionRegistryPostProcessor 类型的后置处理器，用于在后续统一激活该后置处理器的BeanFactoryPostProcessor的实现方法
    67.      registryProcessors.addAll(currentRegistryProcessors);
    68.      // 执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor后置处理器的自定义方法
    69.      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    70.      currentRegistryProcessors.clear();
    72.      // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    73.      // 最后执行没有实现PriorityOrdered和Ordered接口的BeanDefinitionRegistryPostProcessor后置处理器(常规的BeanDefinitionRegistryPostProcessor后置处理器)
    74.      boolean reiterate = true;
    75.      while (reiterate) {
    76.          reiterate = false;
    77.          postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    78.          for (String ppName : postProcessorNames) {
    79.              if (!processedBeans.contains(ppName)) {
    80.                  currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    81.                  processedBeans.add(ppName);
    82.                  reiterate = true;
    83.              }
    84.          }
    85.          // 对常规的BeanDefinitionRegistryPostProcessor后置处理器进行排序
    86.          sortPostProcessors(currentRegistryProcessors, beanFactory);
    87.          // 记录是BeanDefinitionRegistryPostProcessor 类型的后置处理器，用于在后续统一激活该后置处理器的BeanFactoryPostProcessor的实现方法
    88.          registryProcessors.addAll(currentRegistryProcessors);
    89.          // 执行常规的BeanDefinitionRegistryPostProcessor后置处理器的自定义方法
    90.          invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    91.          currentRegistryProcessors.clear();
    92.      }
    94.      // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
    95.      // 激活类型是BeanDefinitionRegistryPostProcessor后置处理器的postProcessBeanFactory()方法
    96.      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    97.      // 激活硬编码注册的常规后置处理器BenFactoryPostProcessor后置处理器
    98.      // 常规的意思是指不是BeanDefinitionRegistryPostProcessor类型的后置处理器，但是BeanFactoryPostProcess类型的后置处理器
    99.      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    100.  }
    102.  else {
    103.      // 执行上下文中注册的工厂处理器
    104.      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    105.  }
    107.  // 获取所有BeanFactoryPostProcessor 类型的后置处理器名称
    108.  String[] postProcessorNames =
    109.      beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    111.  // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    112.  // Ordered, and the rest.
    113.  // 对BeanFactoryPostProcessor 后置处理器按照优先级分类
    114.  // 实现PriorityOrdered接口的后置处理器
    115.  List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    116.  // 实现了Ordered接口的后置处理器的bean名称
    117.  List<String> orderedPostProcessorNames = new ArrayList<>();
    118.  // 存放常规的没有实现排序接口（PriorityOrdered和Ordered接口）的后置处理器的bean名称
    119.  List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    120.  for (String ppName : postProcessorNames) {
    121.      if (processedBeans.contains(ppName)) {
    122.          // 如果bean已经处理过，不再处理
    123.          // skip - already processed in first phase above
    124.      }
    125.      else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    126.          // 实现了PriorityOrdered 接口的BeanFactoryPostProcessor 后置处理器
    127.          priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    128.      }
    129.      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    130.          // 实现了Ordered 接口的BeanFactoryPostProcessor 后置处理器bean名称
    131.          orderedPostProcessorNames.add(ppName);
    132.      }
    133.      else {
    134.          // 没有实现排序的BeanFactoryPostProcessor 后置处理器bean名称
    135.          nonOrderedPostProcessorNames.add(ppName);
    136.      }
    137.  }
    139.  // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    140.  // 对实现了PriorityOrdered接口的BeanFactoryPostProcessor后置处理器进行排序
    141.  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    142.  // 激活实现了PriorityOrdered接口的BeanFactoryPostProcessor后置处理器，既：调用后置处理器的postProcessBeanFactory()方法
    143.  invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    145.  // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    146.  // 获取实现了Ordered接口的BeanFactoryPostProcessor 后置处理器
    147.  List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
    148.  for (String postProcessorName : orderedPostProcessorNames) {
    149.      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    150.  }
    151.  // 对实现了Ordered接口的BeanFactoryPostProcessor 后置处理器排序
    152.  sortPostProcessors(orderedPostProcessors, beanFactory);
    153.  // 激活实现了Ordered接口的BeanFactoryPostProcessor 后置处理器，既：调用后置处理器的postProcessBeanFactory()方法
    154.  invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    156.  // Finally, invoke all other BeanFactoryPostProcessors.
    157.  // 没有实现PriorityOrdered和Ordered接口的BeanFactoryPostProcessor 后置处理器
    158.  List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    159.  for (String postProcessorName : nonOrderedPostProcessorNames) {
    160.      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    161.  }
    162.  // 激活BeanFactoryPostProcessor 后置处理器，既：调用后置处理器的postProcessBeanFactory()方法
    163.  invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    165.  // Clear cached merged bean definitions since the post-processors might have
    166.  // modified the original metadata, e.g. replacing placeholders in values...
    167.  beanFactory.clearMetadataCache();
    168. }

    6. 注册BeanPostProcessor

    我们知道在getBean()的时，实例化bean和初始化bean前后会执行一些后置处理器，那么这些后置处理器是从哪里来的呢？就是在这一步时把所有关于getBean()时所需的后置处理器注册到beanFactory中。在这里不会执行后置处理器，只会把后置处理器加入到beanFactory的属性中，具体的后置处理器执行会在getBean()的时候执行

    1. protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    2.  PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    3. }

    BeanPostProcessor后置处理器注册进beanFactory，具体是由PostProcessorRegistrationDelegate.registerBeanPostProcessors()方法来实现

    1. public static void registerBeanPostProcessors(
    2.  ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    3.  // 获取注册的BeanPostProcessor后置处理器名称
    4.  String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    6.  // 整个容器中的后置处理器数量
    7.  int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    8.  // 添加一个打印后置处理器是否全部正常注册成功的后置处理器
    9.  // 如果被注册的后置处理器的数量少于整个容器中后置处理器的数量，就打印出信息
    10.  beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    12.  // Ordered, and the rest.
    13.  // 存放实现了PriorityOrdered接口的BeanPostProcessor
    14.  List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    15.  // 存放MergedBeanDefinitionPostProcessor 类型的后置处理器
    16.  // MergedBeanDefinitionPostProcessor也是继承BeanPostProcessor接口，具有BeanPostProcessor功能
    17.  List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    18.  // 存放实现了Ordered接口的BeanPostProcessor
    19.  List<String> orderedPostProcessorNames = new ArrayList<>();
    20.  // 存放没有实现PriorityOrdered和Ordered排序接口的BeanPostProcessor，注册时不用保证顺序
    21.  List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    22.  for (String ppName : postProcessorNames) {
    23.      // 实现了PriorityOrdered接口的后置处理器
    24.      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    25.          // 获取后置处理器bean
    26.          BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    27.          // 将实现了PriorityOrdered接口的后置处理器加入到对应集合，在后续统一注册进BeanFactory中
    28.          priorityOrderedPostProcessors.add(pp);
    29.          // 如果是MergedBeanDefinitionPostProcessor 类型，单独处理
    30.          if (pp instanceof MergedBeanDefinitionPostProcessor) {
    31.              internalPostProcessors.add(pp);
    32.          }
    33.      }
    34.      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    35.          // 将实现了Ordered接口的BeanPostProcessor后置处理器加入到对应集合，在后续统一注册进BeanFactory中
    36.          orderedPostProcessorNames.add(ppName);
    37.      }
    38.      else {
    39.          // 没有实现PriorityOrdered和Ordered接口的后置处理器加入对应集合，在后续统一注册进BeanFactory中
    40.          nonOrderedPostProcessorNames.add(ppName);
    41.      }
    42.  }
    44.  // 首先对实现了PriorityOrdered接口的BeanPostProcessor后置处理器排序
    45.  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    46.  // 注册排序好的后置处理器，将后置处理器加入到BeanFactory的beanPostProcessors集合中
    47.  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    49.  // 下一步，注册实现了Ordered接口的BeanPostProcessor后置处理器
    50.  List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    51.  for (String ppName : orderedPostProcessorNames) {
    52.      // 获取后置处理器对象
    53.      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    54.      orderedPostProcessors.add(pp);
    55.      // 如果是MergedBeanDefinitionPostProcessor 类型，单独处理
    56.      if (pp instanceof MergedBeanDefinitionPostProcessor) {
    57.          internalPostProcessors.add(pp);
    58.      }
    59.  }
    60.  // 对实现了Ordered的BeanPostProcessor后置处理器排序
    61.  sortPostProcessors(orderedPostProcessors, beanFactory);
    62.  // 注册排序好的后置处理器，将后置处理器加入到BeanFactory的beanPostProcessors集合中
    63.  registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    65.  // Now, register all regular BeanPostProcessors.
    66.  // 注册将没有实现PriorityOrdered和Ordered接口的BeanPostProcessor后置处理器
    67.  List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    68.  for (String ppName : nonOrderedPostProcessorNames) {
    69.      // 获取后置处理器对象
    70.      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    71.      // 不用保证有序的后置处理器
    72.      nonOrderedPostProcessors.add(pp);
    73.      // 如果是MergedBeanDefinitionPostProcessor 类型，单独处理
    74.      if (pp instanceof MergedBeanDefinitionPostProcessor) {
    75.          internalPostProcessors.add(pp);
    76.      }
    77.  }
    78.  // 注册剩余没有实现PriorityOrdered和Ordered接口的后置处理器，将后置处理器加入到BeanFactory的beanPostProcessors集合中
    79.  // 因为是没有实现排序接口的后置处理器，所以不用保证有序就可以直接注册
    80.  registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    82.  // 最后，将对是MergedBeanDefinitionPostProcessor类型的后置处理器排序
    83.  sortPostProcessors(internalPostProcessors, beanFactory);
    84.  // 注册类型是MergedBeanDefinitionPostProcessor 类型的后置处理器
    85.  registerBeanPostProcessors(beanFactory, internalPostProcessors);
    87.  // 添加ApplicationListener 探测器
    88.  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    89. }

7. 初始化消息资源

为ApplicationContext初始化消息资源，消息资源可以对不同的消息进行国际化。这个方法的逻辑很简单，如果有自定义消息资源管理器就使用自定义的，没有就使用默认的消息资源管理器

  1. protected void initMessageSource() {
  2.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  3.     // 如果配置了messageSource就使用配置的
  4.     if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
  5.         // 创建自定义配置的消息资源bean
  6.         // 将自定义配置的messageSource对象记录在messageSource变量中
  7.         this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
  8.         // Make MessageSource aware of parent MessageSource.
  9.         if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
  10.             HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
  11.             if (hms.getParentMessageSource() == null) {
  12.                 // Only set parent context as parent MessageSource if no parent MessageSource
  13.                 // registered already.
  14.                 hms.setParentMessageSource(getInternalParentMessageSource());
  15.             }
  16.         }
  17.         if (logger.isDebugEnabled()) {
  18.             logger.debug("Using MessageSource [" + this.messageSource + "]");
  19.         }
  20.     }
  21.     else {
  22.         // 没有配置messageSource，就使用默认的
  23.         // Use empty MessageSource to be able to accept getMessage calls.
  24.         DelegatingMessageSource dms = new DelegatingMessageSource();
  25.         dms.setParentMessageSource(getInternalParentMessageSource());
  26.         this.messageSource = dms;
  27.         // 将默认的messageSource注册到单实例bean中
  28.         beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
  29.         if (logger.isDebugEnabled()) {
  30.             logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
  31.                          "': using default [" + this.messageSource + "]");
  32.         }
  33.     }
  34. }

8. 初始化事件广播器

Spring中为我们提供了事件监听功能，事件的发布都是通过事件广播器来发布的，将事件发布出去，事件监听器就能够监听到事件。事件广播器如果可能在这之前就已经创建，比如启动SpringBoot启动时，会提前创建事件广播器。如果已经创建就使用已经创建的事件广播器，没有就使用默认的事件广播器。

  1. protected void initApplicationEventMulticaster() {
  2.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  3.     // 监听器存在，直接从beanFactory中获取
  4.     if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  5.         this.applicationEventMulticaster =
  6.             beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  7.         if (logger.isDebugEnabled()) {
  8.             logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  9.         }
  10.     }
  11.     else {
  12.         // 监听器不存在，注册一个SimpleApplicationEventMulticaster类型的监听器到IOC容器中
  13.         // 注册的意思就是将实例对象作为一个单实例bean放到singletonObjects缓存中
  14.         this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  15.         beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  16.         if (logger.isDebugEnabled()) {
  17.             logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
  18.                          APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
  19.                          "': using default [" + this.applicationEventMulticaster + "]");
  20.         }
  21.     }
  22. }

8.1. 默认事件广播器

SimpleApplicationEventMulticaster 作为默认的事件广播器，里面存放了所有的事件监听器，通过事件广播器发布事件时，会循环调用在事件广播器中的所有监听器

  1. @Override
  2. public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
  3.     ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
  4.     // 遍历监听器，分别执行invokeListener()方法
  5.     for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
  6.         Executor executor = getTaskExecutor();
  7.         // 如果有线程任务，异步执行，最终会执行到监听器的onApplicationEvent()方法
  8.         if (executor != null) {
  9.             // 单独起一个线程，异步执行
  10.             executor.execute(() -> invokeListener(listener, event));
  11.         }
  12.         else {
  13.             // 没有线程任务，同步执行监听器的onApplicationEvent()方法
  14.             invokeListener(listener, event);
  15.         }
  16.     }
  17. }

9. 注册监听器

前面我们已经创建了事件广播器，那么这里将会把监听器添加到事件广播器中。如有有早期需要广播的事件，会将早期事件通过事件广播器广播出去。
在通过事件广播器发布事件时，这些被添加到的事件监听器将会监听到事件。这其实就是典型的观察者模式。

  1. protected void registerListeners() {
  2.     // 硬编码的方式注册事件监听器
  3.     for (ApplicationListener<?> listener : getApplicationListeners()) {
  4.         getApplicationEventMulticaster().addApplicationListener(listener);
  5.     }
  7.     // 通过配置文件注册的监听器处理
  8.     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  9.     for (String listenerBeanName : listenerBeanNames) {
  10.         getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  11.     }
  13.     // 早期事件
  14.     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  15.     this.earlyApplicationEvents = null;
  16.     // 如果有早期事件需要广播，通过事件广播器将事件发布
  17.     if (earlyEventsToProcess != null) {
  18.         // 循环所有早期事件，通过事件广播器将事件广播出去
  19.         // 那些被匹配到的事件监听器将监听到事件
  20.         for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
  21.             getApplicationEventMulticaster().multicastEvent(earlyEvent);
  22.         }
  23.     }
  24. }

10. 创建非延时加载的单例bean

将beanFactory中还没有被创建的单实例bean，进行创建。

  1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  2.     // 为ApplicationContext添加转换器服务
  3.     // 如果容器中存在bean名字为：conversionService的bean，同时类型又是ConversionService.class类型
  4.     // 就说明配置了ConverterService，将其添加到beanFactory的conversionService属性中
  5.     if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  6.         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  7.         beanFactory.setConversionService(
  8.             beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  9.     }
  11.     // Register a default embedded value resolver if no bean post-processor
  12.     // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  13.     // at this point, primarily for resolution in annotation attribute values.
  14.     if (!beanFactory.hasEmbeddedValueResolver()) {
  15.         beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  16.     }
  18.     // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  19.     String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  20.     for (String weaverAwareName : weaverAwareNames) {
  21.         getBean(weaverAwareName);
  22.     }
  24.     // Stop using the temporary ClassLoader for type matching.
  25.     beanFactory.setTempClassLoader(null);
  27.     // 冻结所有bean的定义
  28.     // 说明在这一步之后，bean的BeanDefinition信息将不能被修改
  29.     beanFactory.freezeConfiguration();
  31.     // 创建剩余所有还没有被创建的bean
  32.     beanFactory.preInstantiateSingletons();
  33. }

10.1. 创建剩余bean

ApplicationContext 的实现默认就是在启动时将所有的非延时加载的bean进行创建，而非等到用到该bean时才创建。这么做的好处就是如果bean的创建存在一些问题，在项目启动时就能够发现，而不是等到项目部署以后，用到某个bean时在创建才发现问题，有时某些bean并不是马上就会用到，可能好几天后才能用到。
在前面的几个步骤我们已经创建了一些bean，接下来就是把那些还没有被创建的bean创建出来。

  1. public void preInstantiateSingletons() throws BeansException {
  2.     if (logger.isDebugEnabled()) {
  3.         logger.debug("Pre-instantiating singletons in " + this);
  4.     }
  6.     // 被定义的beanName集合
  7.     List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  9.     // 遍历beanName,创建bean
  10.     for (String beanName : beanNames) {
  11.         // 根据beanName 获取bean的定义信息
  12.         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  13.         // 校验bean的定义信息
  14.         // 只创建非抽象类，是单实例bean，非延迟创建的bean
  15.         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  16.             // 创建FactoryBean类型的bean
  17.             if (isFactoryBean(beanName)) {
  18.                 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  20.                 if (bean instanceof FactoryBean) {
  21.                     FactoryBean<?> factory = (FactoryBean<?>) bean;
  22.                     boolean isEagerInit;
  23.                     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  24.                         isEagerInit = AccessController.doPrivileged(
  25.                             (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  26.                             getAccessControlContext());
  27.                     }
  28.                     else {
  29.                         isEagerInit = (factory instanceof SmartFactoryBean &&
  30.                                        ((SmartFactoryBean<?>) factory).isEagerInit());
  31.                     }
  32.                     if (isEagerInit) {
  33.                         getBean(beanName);
  34.                     }
  35.                 }
  36.             }
  37.             else {
  38.                 // 创建非FatoryBean类型的bean
  39.                 getBean(beanName);
  40.             }
  41.         }
  42.     }
  44.     // Trigger post-initialization callback for all applicable beans...
  45.     // 至此，我们已经创建好了所有的非延时加载的bean
  46.     // 这里将会对SmartInitializingSingleton 类型的bean，执行它的回调方法
  47.     for (String beanName : beanNames) {
  48.         Object singletonInstance = getSingleton(beanName);
  49.         if (singletonInstance instanceof SmartInitializingSingleton) {
  50.             SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  51.             // 安全检查的bean
  52.             if (System.getSecurityManager() != null) {
  53.                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  54.                     smartSingleton.afterSingletonsInstantiated();
  55.                     return null;
  56.                 }, getAccessControlContext());
  57.             }
  58.             else {
  59.                 // 执行回调方法
  60.                 smartSingleton.afterSingletonsInstantiated();
  61.             }
  62.         }
  63.     }
  64. }

11. 完成刷新

在Spring的ApplicationContext 创建完成，所有的非延迟加载的单实例bean被创建后，Spring为我们提供了LifeCycle 接口，通过实现这个接口，在最后会调用LifeCycle接口的start()方法，并在Spring关闭时调用LifeCycle的stop()方法。我们可以实现这个接口来扩展一些功能，如：启动一个后台允许的线程，轮询的收集一些允许信息等

  1. protected void finishRefresh() {
  2.     // 清除上下文中的resourceCaches缓存
  3.     clearResourceCaches();
  5.     // 初始化LifeCycle 处理器
  6.     // 启动LifeCycle接口的方法是通过这个处理器来启动
  7.     initLifecycleProcessor();
  9.     // 通过Lifecycle处理器启动LifeCycle 接口的start()
  10.     getLifecycleProcessor().onRefresh();
  12.     // Publish the final event.
  13.     publishEvent(new ContextRefreshedEvent(this));
  15.     // Participate in LiveBeansView MBean, if active.
  16.     LiveBeansView.registerApplicationContext(this);
  17. }

11.1. 初始化LifeCycleProcessor

创建LifeCycleProcessor处理器，如果有自定义的处理器就创建自定义处理器，没有使用默认的处理器

  1. protected void initLifecycleProcessor() {
  2.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  3.     // 如果LifeCycleProcessor已经创建，或者已经定义了处理器的名称：lifecycleProcessor
  4.     // 那么通过getBean()获取处理器对象
  5.     if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
  6.         this.lifecycleProcessor =
  7.             beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
  8.         if (logger.isTraceEnabled()) {
  9.             logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
  10.         }
  11.     }
  12.     else {
  13.         // 还没有定义LifeCycleProcessor处理器的名称
  14.         // 创建一个默认的处理器，并注册到beanFactory中作为一个单实例bean
  15.         DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
  16.         defaultProcessor.setBeanFactory(beanFactory);
  17.         this.lifecycleProcessor = defaultProcessor;
  18.         beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
  19.         if (logger.isTraceEnabled()) {
  20.             logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
  21.                          "[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
  22.         }
  23.     }
  24. }

11.2. 启动start()

通过LifeCycle处理器，执行所有实现LifeCycle接口类的start()方法

  1. public void onRefresh() {
  2.     // 执行start()
  3.     startBeans(true);
  4.     // LifeCycle 接口运行中标识
  5.     this.running = true;
  6. }

交给startBeans()方法处理

  1. private void startBeans(boolean autoStartupOnly) {
  2.     // 从beanFactory获取已经被创建的LifeCycle 的bean
  3.     Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
  4.     Map<Integer, LifecycleGroup> phases = new HashMap<>();
  5.     // 遍历所有LifeCycle bean
  6.     lifecycleBeans.forEach((beanName, bean) -> {
  7.         // 只允许非自启动和bean是SmartLifeCycle类型，且是自动启动
  8.         if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
  9.             // 如果实现了Phased接口，根据Phase 分组，如果没有默认组是0
  10.             // 将需LifeCycle bean放到各自的组LifeCycleGroup中的members属性中
  11.             // 标识这个组中有哪些LifeCycle bean
  12.             int phase = getPhase(bean);
  13.             LifecycleGroup group = phases.get(phase);
  14.             if (group == null) {
  15.                 // 新建一个组，用于存放本组需要执行的LifeCycle成员
  16.                 group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
  17.                 // 把新建的组放到map中，key为组名称int类型，value 组对象
  18.                 phases.put(phase, group);
  19.             }
  20.             // 往组中添加LifeCycle成员
  21.             group.add(beanName, bean);
  22.         }
  23.     });
  24.     if (!phases.isEmpty()) {
  25.         List<Integer> keys = new ArrayList<>(phases.keySet());
  26.         Collections.sort(keys);
  27.         // 遍历所有的组
  28.         for (Integer key : keys) {
  29.             // 执行组里所有成员的start()
  30.             phases.get(key).start();
  31.         }
  32.     }
  33. }

11.2.1. 获取LifeCycle对象

从beanFactory中获取已经加载的LIfeCycle接口的实现对象

  1. protected Map<String, Lifecycle> getLifecycleBeans() {
  2.     // 当前ApplicationContext中的beanFactory
  3.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  4.     // 存放LifeCycle bean，key为beanName，value为LifeCycle对象
  5.     Map<String, Lifecycle> beans = new LinkedHashMap<>();
  6.     // 获取所有已经被创建的LifeCycle类型的beanName
  7.     String[] beanNames = beanFactory.getBeanNamesForType(Lifecycle.class, false, false);
  8.     // 遍历所有LifeCycle的beanName
  9.     for (String beanName : beanNames) {
  10.         // 如果beanName中第一个字符是&,去掉&字符
  11.         String beanNameToRegister = BeanFactoryUtils.transformedBeanName(beanName);
  12.         // 校验是不是实现了FactoryBean，也就是说是不是FactoryBean类型的bean
  13.         boolean isFactoryBean = beanFactory.isFactoryBean(beanNameToRegister);
  14.         // 识别beanName
  15.         // 如果是FactoryBean类型的bean，获取它的原始bean，需要在beanName前加&字符，否则不用处理beanName
  16.         String beanNameToCheck = (isFactoryBean ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
  18.         // 条件一
  19.         // 单实例bean中有beanName是beanNameToRegister 名称的bean
  20.         // 并且不是FactoryBean类型，或者根据beanNameToCheck名称能匹配到LifeCycle类型的bean
  21.         // 条件二
  22.         // 是SmartLifecycle 类型的bean
  23.         // 满足其中一个条件即可
  24.         if ((beanFactory.containsSingleton(beanNameToRegister) &&
  25.              (!isFactoryBean || matchesBeanType(Lifecycle.class, beanNameToCheck, beanFactory))) ||
  26.             matchesBeanType(SmartLifecycle.class, beanNameToCheck, beanFactory)) {
  27.             // 获取bean的原始实例
  28.             // 为什么说是原始实例，是因为如果bean是FactoryBean类型的，通过beanName获取到的是getObject()方法的对象，而不是这个对象本身
  29.             // 如果想要获得原始实例，需要在beanName前加&字符
  30.             // 非BeanFactory类型的bean，根据beanName就能获取到实例本身
  31.             Object bean = beanFactory.getBean(beanNameToCheck);
  32.             if (bean != this && bean instanceof Lifecycle) {
  33.                 // 放到map集合中
  34.                 beans.put(beanNameToRegister, (Lifecycle) bean);
  35.             }
  36.         }
  37.     }
  38.     return beans;
  39. }

11.2.2. 执行start()

LifecycleGroup 中执行本组中所有LifeCycle成员的start()

  1. public void start() {
  2.     if (this.members.isEmpty()) {
  3.         return;
  4.     }
  5.     if (logger.isInfoEnabled()) {
  6.         logger.info("Starting beans in phase " + this.phase);
  7.     }
  8.     Collections.sort(this.members);
  9.     for (LifecycleGroupMember member : this.members) {
  10.         doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
  11.     }
  12. }

11.3. 发布事件

启动完LifeCycle接口的start()方法后，紧接着发布一个ContextRefreshedEvent 事件

  1. protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
  2.     Assert.notNull(event, "Event must not be null");
  3.     if (logger.isTraceEnabled()) {
  4.         logger.trace("Publishing event in " + getDisplayName() + ": " + event);
  5.     }
  7.     // 如果有需要，将事件对象转换为ApplicationEvent
  8.     ApplicationEvent applicationEvent;
  9.     if (event instanceof ApplicationEvent) {
  10.         applicationEvent = (ApplicationEvent) event;
  11.     }
  12.     else {
  13.         // 非ApplicationEvent类型的事件，装饰为PayloadApplicationEvent 对象
  14.         applicationEvent = new PayloadApplicationEvent<>(this, event);
  15.         if (eventType == null) {
  16.             eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
  17.         }
  18.     }
  20.     // 早期事件，在注册监听器的时候，会广播事件
  21.     if (this.earlyApplicationEvents != null) {
  22.         this.earlyApplicationEvents.add(applicationEvent);
  23.     }
  24.     else {
  25.         // 广播事件
  26.         getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
  27.     }
  29.     // Publish event via parent context as well...
  30.     if (this.parent != null) {
  31.         if (this.parent instanceof AbstractApplicationContext) {
  32.             ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
  33.         }
  34.         else {
  35.             this.parent.publishEvent(event);
  36.         }
  37.     }
  38. }