spring ioc容器创建过程（2）invokeBeanFactoryPostProcessors_invokebeanfactorypostprocessors finishbeanfactoryi-优快云博客

本文链接：https://blog.youkuaiyun.com/lisyee/article/details/119283497

文章目录

上文分析了spring ioc容器的初始化第一步， BeanFactory的初始化今天继续来分析BeanFactoryPostProcessors的初始化和执行流程。

一、BeanFactoryPostProcessors

Spring提供了两种后置处理bean的扩展接口，分别为BeanPostProcessor和BeanFactoryPostProcessor，BeanFactoryPostProcessor是BeanFactory级别的处理，是针对整个Bean的工厂进行处理。

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

可以看到BeanFactoryPostProcessor只是针对于ConfigurableListableBeanFactory类型的beanFactory进行一个后置处理，BeanFactoryPostProcessor是在spring容器加载了bean的定义的配置之后，在bean实例化之前执行的。实现此接口可以spring的bean创建之前，修改bean的定义属性。
spring在处理BeanFactoryPostProcessor的逻辑是:

处理当前上下文的BeanDefinitionRegistryPostProcessor；
处理beanFactory中的BeanDefinitionRegistryPostProcessor；
处理当前上下文的BeanFactoryPostProcessor；
处理beanFactory中的BeanFactoryPostProcessor。

二、spring ioc启动时的处理

1、AbstractApplicationContext#refresh()

//子类覆盖方法做额外的处理
postProcessBeanFactory(beanFactory) ;
//激活各种BeanFactory 处理器
invokeBeanFactoryPostProcessors(beanFactory) ;

在上文中，spring BeanFactory初始化之后，第二步会进行beanFactory处理器的初始化。

1.1、postProcessBeanFactory(beanFactory)

这里是个空的模板方法，留给子类去实现注册BeanFactoryPostProcessor；

1.2、invokeBeanFactoryPostProcessors(beanFactory)

实例化并调用所有已经注册的BeanFactoryPostProcessor

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 调用BeanFactoryPostProcessor 主要对于beanDefinition做后置处理
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
    
        // 如果loadTimeWeaver这个Bean存在，那么就会配置上运行时织入的处理器LoadTimeWeaverAwareProcessor
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

这里有个getBeanFactoryPostProcessors()方法，这个方法是获取AbstractApplicationContext内部的一个List类型属性，保存了手动添加的BeanPostProcessor实例。

public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
        return this.beanFactoryPostProcessors;
}

重点在PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors中

public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
   // 先执行BeanDefinitionRegistryPostProcessors
   // 需要注意的是BeanDefinitionRegistryPostProcessors 为 BeanFactoryPostProcessor 的子接口 
   // 所以BeanDefinitionRegistryPostProcessors，它可以我们介入，改变Bean的一些定义信息，或者动态注入Bean定义
   Set<String> processedBeans = new HashSet<>();
   // 只有此beanFactory是BeanDefinitionRegistry才能执行BeanDefinitionRegistryPostProcessor
   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      // 此处安放了两个容器，一个装载普通的BeanFactoryPostProcessor
      // 另外一个装载和Bean定义有关的 BeanDefinitionRegistryPostProcessor
      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
      // 这里是手动添加到ApplicationContext中的
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            // 这里执行post方法，然后然后吧它缓冲起来了，放在了registryProcessors里
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            registryProcessors.add(registryProcessor);
         }
         else {
            // 缓冲到普通的处理器
            regularPostProcessors.add(postProcessor);
         }
      }
      // 接下来，就是去执行Spring容器里面的一些PostProcessor了。
      // 先执行实现了PriorityOrdered接口的，然后是Ordered接口的，最后执行剩下的
      List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
      //首先，调用继承于PriorityOrdered接口的BeanDefinitionRegistryPostProcessors
      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);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      // 此处缓冲起来（排序后）
      registryProcessors.addAll(currentRegistryProcessors);
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
      // 此处把当前持有的执行对象给清空了，需要注意。以方便装载后续执行的处理器们
      currentRegistryProcessors.clear();
      // 此处逻辑完全同上  处理实现Order接口的RegistryProcessors
      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, beanFactory.getApplicationStartup());
      currentRegistryProcessors.clear();
      // 最后执行，两个排序接口都没有实现的BeanDefinitionRegistryPostProcessor们，并且也缓存起来
      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, beanFactory.getApplicationStartup());
         currentRegistryProcessors.clear();
      }
      //调用到目前为止processors处理过的 postProcessBeanFactory的回调函数
      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }
   else {
      // 若是普通的Bean工厂，就直接执行set进来的后置处理器即可（因为容器里就没有其它Bean定义了）
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }
   // 下面就是开始执行BeanFactoryPostProcessor 基本也是按照上面的顺序来执行的
   // 执行使用配置注册的
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
   // 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)) {
      }
      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);
      }
   }
    //首先执行实现了PriorityOrdered的BeanFactoryPostProcessors
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
   //然后执行实现Ordered的BeanFactoryPostProcessors
   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
   //最后执行剩下所有的BeanFactoryPostProcessors
   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();
}

需要关注的点：
• BeanFactoryPostProcessor的执行顺序问题(实现了PriorityOrdered > 实现了Ordered > 什么都没实现)
• 对于BeanDefinitionRegistryPostProcessor的处理,在这里面可以动态修改或者增加BeanDefinition

三、总结

AbstractApplicationContext#invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory) 方法，主要是执行 BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 的处理，会做以下事情：

如果当前 Spring 应用上下文是 BeanDefinitionRegistry 类型，则执行当前 Spring 应用上下文中所有 BeanDefinitionRegistryPostProcessor、BeanFactoryPostProcessor 的处理，以及底层 BeanFactory 容器中 BeanDefinitionRegistryPostProcessor 的处理，处理顺序如下：
（1）当前 Spring 应用上下文中所有 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
（2）底层 BeanFactory 容器中所有 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry（优先级：PriorityOrdered > Ordered > 无）
（3）当前 Spring 应用上下文和底层 BeanFactory 容器中所有 BeanDefinitionRegistryPostProcessor#postProcessBeanFactory
（4）当前 Spring 应用上下文中所有 BeanFactoryPostProcessor#postProcessBeanFactory
否则，执行当前 Spring 应用上下文中所有 BeanFactoryPostProcessor#postProcessBeanFactory
执行底层 BeanFactory 容器中所有 BeanFactoryPostProcessor#postProcessBeanFactory，上面已经处理过的会跳过，执行顺序和上面一样：PriorityOrdered > Ordered > 无