概述

invokeBeanFactoryPostProcessors方法是Spring初始化流程中执行的第五个方法，那么这个方法中具体干了什么呢?
总结起来就是干了两件事:
1、将所有bean定义的class扫描进BeanFactory中
2、提前实例化了一部分bean

而在这个方法中有两个很关键的类，BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor,这两个类是非常容易搞混的，可以先来看下这两个类的继承和实现关系

BeanFactoryPostProcessor是一个接口

再来看一下BeanDefinitionRegistryPostProcessor
同样也是一个接口，但是这个接口继承了BeanFactoryPostProcessor

那这两个类有什么不同呢？
BeanFactoryPostProcessor主要针对的操作对象是BeanFactory
BeanDefinitionRegistryPostProcessor主要针对的操作对象是BeanDefinition

正文

invokeBeanFactoryPostProcessors源码分析

首先还是先看refresh方法，可以看到invokeBeanFactoryPostProcessors是第五个调用的方法

该方法会调用到

而在这个方法中我们可以看到在invokeBeanFactoryPostProcessors方法中有两个参数，一个是beanFactory、一个是getBeanFactoryPostProcessors()
getBeanFactoryPostProcessors()回去获取到当前的beanFactoryPostProcessors，不过一般情况下默认为空。接着往下看，进入invokeBeanFactoryPostProcessors方法中

{

   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
   // 将已经执行过的BFPP存储在processedBeans中，防止重复执行
   Set processedBeans = new HashSet<>();

   // 判断beanfactory是否是BeanDefinitionRegistry类型，此处是DefaultListableBeanFactory,实现了BeanDefinitionRegistry接口，所以为true
   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      // 存放BeanFactoryPostProcessor的集合 BeanFactoryPostProcessor主要针对的操作对象是BeanFactory
      List regularPostProcessors = new ArrayList<>();
      // 存放BeanDefinitionRegistryPostProcessor的集合 BeanDefinitionRegistryPostProcessor主要针对的操作对象是BeanDefinition
      List registryProcessors = new ArrayList<>();

      // 首先处理入参中的beanFactoryPostProcessors,遍历所有的beanFactoryPostProcessors，将BeanDefinitionRegistryPostProcessor
      // 和BeanFactoryPostProcessor区分开
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         // 如果是BeanDefinitionRegistryPostProcessor
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            // 直接执行BeanDefinitionRegistryPostProcessor接口中的postProcessBeanDefinitionRegistry方法
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            // 添加到registryProcessors，用于后续执行postProcessBeanFactory方法
            registryProcessors.add(registryProcessor);
         }
         else {
            // 否则，只是普通的BeanFactoryPostProcessor，添加到regularPostProcessors，用于后续执行postProcessBeanFactory方法
            regularPostProcessors.add(postProcessor);
         }
      }

      // 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
      List currentRegistryProcessors = new ArrayList<>();

      // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
      // 调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
      // 找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         // 检测是否实现了PriorityOrdered接口
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 获取名字对应的bean实例，添加到currentRegistryProcessors中
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
            processedBeans.add(ppName);
         }
      }
      // 按照优先级进行排序操作
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
      registryProcessors.addAll(currentRegistryProcessors);
      // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      // 执行完毕之后，清空currentRegistryProcessors
      currentRegistryProcessors.clear();

      // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
      // 调用所有实现Ordered接口的BeanDefinitionRegistryPostProcessor实现类
      // 找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName，
      // 此处需要重复查找的原因在于上面的执行过程中可能会新增其他的BeanDefinitionRegistryPostProcessor
      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;
         // 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
         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.
      // 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
      // 最后，调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }

   else {
      // Invoke factory processors registered with the context instance.
      // 如果beanFactory不归属于BeanDefinitionRegistry类型，那么直接执行postProcessBeanFactory方法
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }
   // 到这里为止，入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕，下面开始处理容器中
   // 所有的BeanFactoryPostProcessor
   // 可能会包含一些实现类，只实现了BeanFactoryPostProcessor，并没有实现BeanDefinitionRegistryPostProcessor接口

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

   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   // 用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
   List priorityOrderedPostProcessors = new ArrayList<>();
   // 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
   List orderedPostProcessorNames = new ArrayList<>();
   // 用于存放普通BeanFactoryPostProcessor的beanName
   List nonOrderedPostProcessorNames = new ArrayList<>();
   // 遍历postProcessorNames,将BeanFactoryPostProcessor按实现PriorityOrdered、实现Ordered接口、普通三种区分开
   for (String ppName : postProcessorNames) {
      if (processedBeans.contains(ppName)) {
         // skip - already processed in first phase above
      }
      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.
   // 对实现了PriorityOrdered接口的BeanFactoryPostProcessor进行排序
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   // 遍历实现了PriorityOrdered接口的BeanFactoryPostProcessor，执行postProcessBeanFactory方法
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   List 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.
   List 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();
}

1. 拿到所有的bean工厂后处理器。创建两个list，一个放BeanFactoryPostProcessor类型的后处理器，一个放BeanDefinitionRegistryPostProcessor类型的后置处理器。
2. 创建一个list，用于存放当前准备创建的BeanDefinitionRegistryPostProcessor。 currentRegistryProcessors
3. 在容器（beanfactory）中获取所有实现了BeanDefinitionRegistryPostProcessor的后处理器。
4. 遍历从容器中拿到的后处理器，判断是否实现PriorityOrdered接口，true 直接getbean（），并把这个bean加入到processedBeans（已经处理过的bean）中。
5. 对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
6. 把刚才2步骤中新加的加入到1步骤的一个BeanDefinitionRegistryPostProcessorlist中。
7. 进行bean定义的加载 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
8. 调用完成之后currentRegistryProcessors.clear清空。
9. 去容器中获取BeanDefinitionRegistryPostProcessor