spring源码：注册后置处理器

目的

程序员在对spring扩展的时候，可以自己实现后置处理器，完成特定的业务操作，该篇博客，主要是学习spring如何将程序员提供的后置处理器添加到spring容器中的;
顺带，将spring初始化流程中，其他几个方法做一个大致的解析和介绍

源码学习

registerBeanPostProcessors(beanFactory);

该方法是用来完成，注册BeanPostProcessor实现类的
如果我们自己实现了BeanPostProcessor接口，并提供了自己的业务处理逻辑，spring首先会把我们提供的BeanPostProcessor实现类，在实例化业务bean之前，先实例化，并存入特定的集合中；

org.springframework.context.support.AbstractApplicationContext#registerBeanPostProcessors

这个方法，就是用来处理后置处理器的
所以：这个方法归结而言，就完成了两件事情

把所有的BeanPostProcessor（包括spring自己的 + 我们提供的）进行初始化，并存入到spring容器中(signletonObjects这个集合中)
把所有的BeanPostProcessor存入到一个list中（private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();）

public static void registerBeanPostProcessors(
    ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

  /**
 * 1.获取到所有实现了beanPostProcessor接口的实现类的name,从beanDefinitionMaps中获取
 *  这里在从BeanDefinitionMap中获取BeanPostProcessor类型的实现类的时候，会进行bean的合并，也即：将bean转换Wie
   */
  String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

  // Register BeanPostProcessorChecker that logs an info message when
  // a bean is created during BeanPostProcessor instantiation, i.e. when
  // a bean is not eligible for getting processed by all BeanPostProcessors.
  int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
  beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

  // Separate between BeanPostProcessors that implement PriorityOrdered,
  // Ordered, and the rest.
  /**
 * 2.internalPostProcessors:存储的是实现了MergedBeanDefinitionPostProcessor接口的实现类
 * 这里没想明白为什么要把实现了该接口的实现类单独存储
   */
  List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
  List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
  List<String> orderedPostProcessorNames = new ArrayList<>();
  List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  /**
 * 3.按照后置处理器实现的ordered接口 分别存到不同的集合中
   */
  for (String ppName : postProcessorNames) {
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
      /**
       * 4.在调用getBean的时候，就会调用对应的初始化方法，完成对beanPostProcessor的初始化
       */
      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);
    }
  }

  // First, register the BeanPostProcessors that implement PriorityOrdered.
  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  /**
 * 5.registerBeanPostProcessors:该方法，就是把入参中的beanPostProcessor实现类存入到beanPostProcessors这个list集合中
   */
  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

  // Next, register the BeanPostProcessors that implement Ordered.
  List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
  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<>();
  for (String ppName : nonOrderedPostProcessorNames) {
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    nonOrderedPostProcessors.add(pp);
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
      internalPostProcessors.add(pp);
    }
  }
  registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

  sortPostProcessors(internalPostProcessors, beanFactory);
  registerBeanPostProcessors(beanFactory, internalPostProcessors);

  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

这里的逻辑还是比较简单的，但是与几个点需要注意：

在第一点：从beanDefinitionMap中获取beanPostProcessor的实现类的时候，会对beanDefinition进行一次合并(将beanDefinition合并为RootBeanDefinition,这里的合并bean，在后面的博客中进行说明，这里暂时记一下就好)
在获取到所有的BeanPostProcessor实现类的时候，会对实现类进行优先级的分类，实现了PriorityOrdered > 实现了Ordered > 普通的实现类
registerBeanPostProcessors(beanFactory, internalPostProcessors);该方法就是将实例化好的BeanPostProcessor实现类放入到beanPostProcessors这个集合中
在调用getBean()方法的时候，会从单实例池中尝试获取bean，如果bean不存在，就初始化、实例化；也即：在源码中第4点这里，会完成对beanPostProcessor的实例化(意思就是说：经过第4点之后，我们自己提供的beanPostProcessor和spring自己的后置处理器已经走完了整个生命周期流程，是一个合格的bean了)

initMessageSource();

这个方法，暂时还没来得及看，百度了一下，说是用来做国际化、消息绑定等，这里待后面学习之后再补充

initApplicationEventMulticaster();

在这个方法中，初始化了一个多事件派发器ApplicationEventMulticaster，用来做事件发布的

onRefresh();

这是一个扩展方法，在spring framework中是一个空方法，留给子接口进行扩展，其中：springboot启动的源码中，就对该方法做了扩展

registerListeners();

看名字，是用来注册事件监听器的，暂时未学习

finishBeanFactoryInitialization(beanFactory);

这是完成bean实例化的重要方法，在后面会介绍这个方法中的每个核心方法

finishRefresh();

在完成spring的初始化之后，发布ContextRefreshedEvent事件，当然，还有其他的操作，这个方法，也没有做过多的学习，待后面补充吧

接下来，我主要想分享的是finishBeanFactoryInitialization这个方法，这个方法中，是spring将扫描之后的beanDefinition初始化为bean对应，并存入到spring容器中的核心方法