Spring源码-ApplicationContext

spring框架中的BeanFactory和ApplicationContext是非常重要的俩个接口。
ApplicationContext是BeanFactory的子接口，BeanFactory是IOC容器，ApplicationContext是应用的上下文除了实现了BeanFactory还实现了配置文件的读取等操作。
所有的bean初始化都在ApplicationContext的refresh方法中完成。本文以AnnotationConfigApplicationContext为例。

继承关系图如下

BeanFactory

名字的直译是Bean工厂，我们定义的Bean在这里就行初始化。图中真正可以作为一个独立使用的IOC容器的是DefaultListableBeanFactory

BeanFactory主要的方法是getBean，用来获取Bean

3个子接口：

• HierarchicalBeanFactory:提供父容器的访问功能
• ListableBeanFactory:提供了批量获取Bean的方法
• AutowireCapableBeanFactory:在BeanFactory基础上实现对已存在实例的管理

public interface HierarchicalBeanFactory extends BeanFactory {

    //返回父类的BeanFactory
    BeanFactory getParentBeanFactory();

    //当前beanfacatory是否包含bean，不会去父类的BeanFactory找
    boolean containsLocalBean(String name);
}

//提供通过beanName、类型查找Bean的接口
public interface ListableBeanFactory extends BeanFactory {

    boolean containsBeanDefinition(String beanName);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionNames();

    String[] getBeanNamesForType(ResolvableType type);

    String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);

    String[] getBeanNamesForType(@Nullable Class<?> type);

    String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

    <T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;

    <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)throws BeansException;


    String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);


    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;


    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)throws NoSuchBeanDefinitionException;
}

public interface AutowireCapableBeanFactory extends BeanFactory {

    int AUTOWIRE_NO = 0;//按照构造方法自动装配
    int AUTOWIRE_BY_NAME = 1;//按照名称autowire
    int AUTOWIRE_BY_TYPE = 2;//按照类型autowire
    int AUTOWIRE_CONSTRUCTOR = 3;//按照构造方法自动装配

    // 使用autowireBeanProperties装配属性
    void autowireBean(Object existingBean) throws BeansException;

    // 自动装配属性,填充属性值,使用诸如setBeanName,setBeanFactory这样的工厂回调填充属性,最好还要调用post processor
    Object configureBean(Object existingBean, String beanName) throws BeansException;

    //会执行bean完整的初始化,包括BeanPostProcessors和initializeBean
    Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
}

AnnotationConfigApplicationContext

构造方法：我们以下面的构造方法为例

public AnnotationConfigApplicationContext(String... basePackages) {
  //无参构造函数，-->GenericApplicationContext-->初始化（beanFactory = new DefaultListableBeanFactory()）
  this();
  //扫描包下面的注解，默认支持Commponent（以及他的子类），javax.annotation.ManagedBean，javax.inject.Named
  scan(basePackages);
  //刷新上下文
  refresh();
}

this()做了什么

1. 调用父类GenericApplicationContext的无参构造方法,在GenericApplicationContext中初始化DefaultListableBeanFactory
2. 自己的构造方法初始化BeanDefinition的读取器和类扫描器

public GenericApplicationContext() {
  this.beanFactory = new DefaultListableBeanFactory();
}

public AnnotationConfigApplicationContext() {
  //IOC容器初始化注解BeanDefinition的读取器，如果需要注册指定的类就采用reader.register
  this.reader = new AnnotatedBeanDefinitionReader(this);
  //IOC容器初始化类扫描器，如果是需要扫描某个包下的注解就用scanner.scan
  this.scanner = new ClassPathBeanDefinitionScanner(this);
}

scan or register

AnnotationConfigApplicationContext的构造方法一般支持俩种，注册某些Component注解、扫描某一个包，他们具体的区别就在构造方法中的register或者scan，俩者逻辑都差不多，这里我们

• scan(basePackages)，它会调用scanner.scan(basePackages)。scan扫描的bean的注解默认只支持Commponent（以及他的子类），javax.annotation.ManagedBean，javax.inject.Named，如果有特殊的注解需要需要自己实现

• register(componentClasses),他会调用reader.register(componentClasses)。register注册的bean可以不用加注解。

  这一步实际上是对入参的basePackage或者class，进行扫描或者注册，生成BeanDefinition保存到容器中。BeanDefinition封装了Class的MetaInfo，包含了类名，属性，方法，父类信息等。便于后续根据的BeanDefinition对其包含的对象进行初始化。

  我们来看下 //todo

refresh

真正bean的初始化过程。

@Override
public void refresh() throws BeansException, IllegalStateException {
  //防止并发情况下多次初始化
  synchronized (this.startupShutdownMonitor) {
    // 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);

      // Invoke factory processors registered as beans in the context.
      invokeBeanFactoryPostProcessors(beanFactory);

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

      // 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();
    }
  }
}

下面我们一步步的看

prepareRefresh

为refresh做准备，设置Application的startUpdate,将状态改为active，同时初始化properties。

obtainFreshBeanFactory

重新刷新BeanFactrory,代码如下

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  refreshBeanFactory();
  return getBeanFactory();
}

这里的refreshBeanFactory()俩个实现，GenericApplicationContext和AbstractRefreshableApplicationContext

GenericApplicationContext对应的是本文的Annotation在ApplicationContext的构造方法中已经register/scan过，BeanDefinition了这里就不用创建beanfactroy在加载一遍bean了

@Override
protected final void refreshBeanFactory() throws IllegalStateException {
  //因为在ApplicationContext的构造方法中已经register/scan过BeanDefinition了这里就不用在重新创建beanfactroy，在加载一边bean了
  if (!this.refreshed.compareAndSet(false, true)) {
    throw new IllegalStateException(
        "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
  }
  this.beanFactory.setSerializationId(getId());
}

AbstractRefreshableApplicationContext对应的是xml，file等方式，在构造方法中只是加载文件没有创建BeanDefinition,所在这里要创建BeanDefinition对象

@Override
protected final void refreshBeanFactory() throws BeansException {
  if (hasBeanFactory()) {
    destroyBeans();
    closeBeanFactory();
  }
  try {
    DefaultListableBeanFactory beanFactory = createBeanFactory();
    beanFactory.setSerializationId(getId());
    customizeBeanFactory(beanFactory);
    //根据构造函数传入到file地址创建，加载BeanDefinition，
    loadBeanDefinitions(beanFactory);
    synchronized (this.beanFactoryMonitor) {
      this.beanFactory = beanFactory;
    }
  }
  catch (IOException ex) {
    throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  }
}

prepareBeanFactory

设置beanFactory的classloader，spel表达式，bean的属性处理器，自动装配的例外/特殊规则，BeanProcessor，env等

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  // Tell the internal bean factory to use the context's class loader etc.'
  //设置classloader为当前contextLocader
  beanFactory.setBeanClassLoader(getClassLoader());
  //设置spel表达式
  beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  //设置ResourceEditor,用于初始化bean时候填充bean的属性
  beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

  // Configure the bean factory with context callbacks.
  //设置ApplicationContextAwareProcessor实现了BeanPostProcessor，作用：程序可以获取ApplicationContext
  // 例：我们程序中自定义MyApplicationContextAware实现ApplicationContextAware接口
  // ApplicationContextAwareProcessor在bean初始化前会调用，postProcessBeforeInitialization然后调用MyApplicationContextAware.setApplictionContext
  beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  //添加忽略规则，因为在Bean实例化过程中，这些依赖未必会实例化，所以选择忽略，如果bean需要这些依赖，可以采用set等方式。
  beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

  // BeanFactory interface not registered as resolvable type in a plain factory.
  // MessageSource registered (and found for autowiring) as a bean.
  //设置自动装配的规则
  beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  beanFactory.registerResolvableDependency(ApplicationContext.class, this);

  // Register early post-processor for detecting inner beans as ApplicationListeners.
  //设置容器的后置BeanPostProcessor处理器，将ApplicationListener注册到容器中，见postProcessAfterInitialization
  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

  // Detect a LoadTimeWeaver and prepare for weaving, if found.
  //判断是否有loadTimeWeaver
  if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    //LoadTimeWeaverAwareProcessor-->从容器中获取loadTimeWeaver，然后添加到LoadTimeWeaverAware中
    beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    // Set a temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  }

  // Register default environment beans.
  if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  }
  if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  }
  if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  }
}

postProcessBeanFactory

没有具体实现的空方法，在beanFactory都设置好以后，留给容器根据自己的使用场景自己定制如：web容器注入一些重要资源（类似Application的属性和ServletContext的属性），我们可以实现该方法。

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

//在GenericWebApplicationContext中
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  if (this.servletContext != null) {
    beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
    beanFactory.ignoreDependencyInterface(ServletContextAware.class);
  }
  WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
  WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
}

invokeBeanFactoryPostProcessors(beanFactory)

容器执行内置的以及用户自定义的BeanDefinitionRegistryPostProcessor以及BeanFactoryPostProcessor的postProcessBeanFactory方法。

BeanDefinitionRegistryPostProcessor作用见链接Spring源码-BeanDefinitionRegistryPostProcessor

流程如下：

1. invokeBeanFactoryPostProcessors调用PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法
2. 执行容器注册好的BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry以及BeanFactoryPostProcessor.postBeanFactory，优先级是实现PriorityOrder接口，Order注解，其他
   1. BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry，见ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry，将Component,Import ImportResource Component注解的类解析Configuratuon
   2. 执行BeanFactoryPostProcessor.postBeanFactory。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  //关键代码,执行容器注册的BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry以及BeanFactoryPostProcessor.postBeanFactory
  PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

  // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
  // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  }
}

  /**
 * 执行容器注册号的BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry以及BeanFactoryPostProcessor.postBeanFactory，
 * 优先级是实现PriorityOrder接口，Order注解，其他
 * 1.BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry，
     见ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry，将Component,Import ImportResource Component注解的类解析Configuratuon
 * 2. 执行BeanFactoryPostProcessor.postBeanFactory
 * @param beanFactory obtainFreshBeanFactory()返回的factory即DefaultListableBeanFactory
 * @param beanFactoryPostProcessors 第一次调用时候为空
 */
public static void invokeBeanFactoryPostProcessors(
    ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

  // Invoke BeanDefinitionRegistryPostProcessors first, if any.
  Set<String> processedBeans = new HashSet<>();
  //DefaultListableBeanFactory这里是true
  if (beanFactory instanceof BeanDefinitionRegistry) {
    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

    List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

    for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
      if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
        BeanDefinitionRegistryPostProcessor registryProcessor =
            (BeanDefinitionRegistryPostProcessor) postProcessor;
        registryProcessor.postProcessBeanDefinitionRegistry(registry);
        //添加到registryProcessors中
        registryProcessors.add(registryProcessor);
      }
      else {
        regularPostProcessors.add(postProcessor);
      }
    }

    /**
     * 优先执行容器中BeanDefinitionRegistryPostProcessor的，BeanDefinitionRegistryPostProcessor的作用可以动态注册bean
     */
    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let the bean factory post-processors apply to them!
    // Separate between BeanDefinitionRegistryPostProcessors that implement
    // PriorityOrdered, Ordered, and the rest.
    List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

    //优先执行实现PriorityOrdered接口的currentRegistryProcessors
    // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    for (String ppName : postProcessorNames) {
      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
        processedBeans.add(ppName);
      }
    }
    //关键代码：调用ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry，执行postProcessBeanDefinitionRegistry
    sortPostProcessors(currentRegistryProcessors, beanFactory);
    registryProcessors.addAll(currentRegistryProcessors);
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    currentRegistryProcessors.clear();

    // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
    //其次执行实现了Ordered的BeanDefinitionRegistryPostProcessors
    postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    for (String ppName : postProcessorNames) {
      if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
        processedBeans.add(ppName);
      }
    }
    sortPostProcessors(currentRegistryProcessors, beanFactory);
    registryProcessors.addAll(currentRegistryProcessors);
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    currentRegistryProcessors.clear();

    // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    //执行普通的BeanDefinitionRegistryPostProcessors
    boolean reiterate = true;
    while (reiterate) {
      reiterate = false;
      postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
        if (!processedBeans.contains(ppName)) {
          currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
          processedBeans.add(ppName);
          reiterate = true;
        }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();
    }

    // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
    //执行postProcessBeanFactory
    invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
  }

  else {
    // Invoke factory processors registered with the context instance.
    invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
  }

  // Do not initialize FactoryBeans here: We need to leave all regular beans
  // uninitialized to let the bean factory post-processors apply to them!
  String[] postProcessorNames =
      beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

  //处理BeanFactoryPostProcessor，BeanFactoryPostProcessor分为priorityOrdered、Odered和Non三类分别处理
  // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
  // Ordered, and the rest.
  List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
  List<String> orderedPostProcessorNames = new ArrayList<>();
  List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  for (String ppName : postProcessorNames) {
    if (processedBeans.contains(ppName)) {
      // skip - already processed in first phase above
    }
    //todo  这里很不理解为啥priorityOrderedPostProcessors和orderedPostProcessorNames逻辑不一样
    else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
      priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    }
    else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
      orderedPostProcessorNames.add(ppName);
    }
    else {
      nonOrderedPostProcessorNames.add(ppName);
    }
  }

  // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
  //priorityOrderedPostProcessors排序，并且执行自定义的postProcessBeanFactory
  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

  // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
  //加载orderedPostProcessors排序，并且执行自定义的postProcessBeanFactory
  List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
  for (String postProcessorName : orderedPostProcessorNames) {
    orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  }
  sortPostProcessors(orderedPostProcessors, beanFactory);
  invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

  // Finally, invoke all other BeanFactoryPostProcessors.
  //加载nonOrderedPostProcessors、并且执行自定义的postProcessBeanFactory
  List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
  for (String postProcessorName : nonOrderedPostProcessorNames) {
    nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  }
  invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

  // Clear cached merged bean definitions since the post-processors might have
  // modified the original metadata, e.g. replacing placeholders in values...
  beanFactory.clearMetadataCache();
}

registerBeanPostProcessors

注册执行BeanPostProcessors，这指是注册BeanPostProcessors，并没有执行

流程如下：

1. registerBeanPostProcessors->PostProcessorRegistrationDelegate.registerBeanPostProcessors
2. 在registerBeanPostProcessors取得所有的BeanPostProcessor
3. 对BeanPostProcessors分组，分成:PriorityOrdered，Ordered，nonOrdered，internal(属于MergedBeanDefinitionPostProcessor)
4. 对他们进行排序，注册顺序是PriorityOrdered->Ordered->nonOrdered->internal–>ApplicationListenerDetector

public static void registerBeanPostProcessors(
    ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
  //获取所有的BeanPostProcessor
  String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

  ////bean不是基础BeanPostProcessor && bean的Role不是ROLE_INFRASTRUCTURE && beanFactory.getBeanPostProcessorCount()<beanPostProcessorTargetCount
  int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
  beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

  // Separate between BeanPostProcessors that implement PriorityOrdered,
  // Ordered, and the rest.
  //将BeanPostProcessor分类
  //对BeanPostProcessors分组，分成:PriorityOrdered，Ordered，nonOrdered，internal(属于MergedBeanDefinitionPostProcessor)
  List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
  List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
  List<String> orderedPostProcessorNames = new ArrayList<>();//todo 同理，这里为什么是orderedPostProcessorNames，为什么不和priorityOrderedPostProcessors逻辑
  List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  for (String ppName : postProcessorNames) {
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      priorityOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
        internalPostProcessors.add(pp);
      }
    }
    else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
      orderedPostProcessorNames.add(ppName);
    }
    else {
      nonOrderedPostProcessorNames.add(ppName);
    }
  }

  //执行顺序是PriorityOrdered->Ordered->nonOrdered->internal-->ApplicationListenerDetector

  // First, register the BeanPostProcessors that implement PriorityOrdered.
  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

  // Next, register the BeanPostProcessors that implement Ordered.
  List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
  for (String ppName : orderedPostProcessorNames) {
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    orderedPostProcessors.add(pp);
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
      internalPostProcessors.add(pp);
    }
  }
  sortPostProcessors(orderedPostProcessors, beanFactory);
  registerBeanPostProcessors(beanFactory, orderedPostProcessors);

  // Now, register all regular BeanPostProcessors.
  List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
  for (String ppName : nonOrderedPostProcessorNames) {
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    nonOrderedPostProcessors.add(pp);
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
      internalPostProcessors.add(pp);
    }
  }
  registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

  // Finally, re-register all internal BeanPostProcessors.
  sortPostProcessors(internalPostProcessors, beanFactory);
  registerBeanPostProcessors(beanFactory, internalPostProcessors);

  // Re-register post-processor for detecting inner beans as ApplicationListeners,
  // moving it to the end of the processor chain (for picking up proxies etc).
  //注册一个特殊的BeanPostProcessor，ApplicationListenerDetector是一个修饰器类，他会见ApplicationListener重新注册给application。
  //这就是多一个参数applicationContext的一一，在最后一位
  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

initMessageSource

【todo】暂时忽略

initApplicationEventMulticaster

【注册时间监听器】后续单独拿出一章讲。
这里，注册ApplicationEventMulticaster 默认 SimpleApplicationEventMulticaster

registerListeners

注册定义的ApplicationListener，注册容器的event和自定义的eventListener

protected void registerListeners() {
  // Register statically specified listeners first.
  for (ApplicationListener<?> listener : getApplicationListeners()) {
    getApplicationEventMulticaster().addApplicationListener(listener);
  }

  // Do not initialize FactoryBeans here: We need to leave all regular beans
  // uninitialized to let post-processors apply to them!
  //所有ApplicationListener的实现者
  String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  for (String listenerBeanName : listenerBeanNames) {
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  }

  // Publish early application events now that we finally have a multicaster...
  Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  this.earlyApplicationEvents = null;
  if (earlyEventsToProcess != null) {
    for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
      getApplicationEventMulticaster().multicastEvent(earlyEvent);
    }
  }
}

preInstantiateSingletons

对之前在AplicationContext构造方法中，scan或者register时候生成的BeanDefinition进行实例化，注意，这里只针对，单例、非延迟加载的BeanDefinition的实体化，具体方法在DefaultListableBeanFactory.preInstantiateSingletons中。见：Spring源码-BeanDefinition

@Override
public void preInstantiateSingletons() throws BeansException {
  if (logger.isTraceEnabled()) {
    logger.trace("Pre-instantiating singletons in " + this);
  }

  // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

  // Trigger initialization of all non-lazy singleton beans...
  for (String beanName : beanNames) {
    //在之前的步骤中的getBeanNamesForType方法会调用getMergedLocalBeanDefinition中
    //todo  将BeanDefinition写入到mergedBeanDefinitions中，后续单独讲BeanDefinition时候单独说
    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    //bd非抽象 && 单利 && 不延迟加载
    if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
      //如果是factoryBean通过"&beanName"得到factoryBean
      if (isFactoryBean(beanName)) {
        //这一步很关键，如果是factory先初始化factroyBean
        Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
        if (bean instanceof FactoryBean) {
          final FactoryBean<?> factory = (FactoryBean<?>) bean;
          boolean isEagerInit;
          //如果isEagerInit为true，则通过factoryBean.getObject()获取actoryBean中的对象
          if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
            isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                    ((SmartFactoryBean<?>) factory)::isEagerInit,
                getAccessControlContext());
          }
          else {
            isEagerInit = (factory instanceof SmartFactoryBean &&
                ((SmartFactoryBean<?>) factory).isEagerInit());
          }
          if (isEagerInit) {
            getBean(beanName);
          }
        }
      }
      else {
        //普通的bean初始化bean
        getBean(beanName);
      }
    }
  }

  // Trigger post-initialization callback for all applicable beans...
  for (String beanName : beanNames) {
    Object singletonInstance = getSingleton(beanName);
    if (singletonInstance instanceof SmartInitializingSingleton) {
      final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
      if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
          smartSingleton.afterSingletonsInstantiated();
          return null;
        }, getAccessControlContext());
      }
      else {
        smartSingleton.afterSingletonsInstantiated();
      }
    }
  }
}

finishRefresh

完成applicationContext的refresh，发送系统事件等

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

  // Initialize lifecycle processor for this context.
  //初始化LifecycleProcessor，todo mark 作用还需要单独了解
  initLifecycleProcessor();

  // Propagate refresh to lifecycle processor first.
  //调用上面的LifecycleProcessor.onRefresh()
  getLifecycleProcessor().onRefresh();

  // Publish the final event.发送ContextRefreshedEvent事件
  publishEvent(new ContextRefreshedEvent(this));

  // Participate in LiveBeansView MBean, if active.
  //todo mark 作用还需要单独了解
  LiveBeansView.registerApplicationContext(this);
}