Springboot扩展点之BeanFactoryPostProcessor

逃离我推掉我的手 2024-03-27 11:05 78阅读 0赞

Springboot扩展点系列实现方式、工作原理集合：

[Springboot扩展点之ApplicationContextInitializer][Springboot_ApplicationContextInitializer]

[Springboot扩展点之BeanFactoryPostProcessor][Springboot_BeanFactoryPostProcessor]

[Springboot扩展点之BeanDefinitionRegistryPostProcessor][Springboot_BeanDefinitionRegistryPostProcessor]

[Springboot扩展点之BeanPostProcessor][Springboot_BeanPostProcessor]

[Springboot扩展点之InstantiationAwareBeanPostProcessor][Springboot_InstantiationAwareBeanPostProcessor]

[Springboot扩展点之SmartInstantiationAwareBeanPostProcessor][Springboot_SmartInstantiationAwareBeanPostProcessor]

[Springboot扩展点之ApplicationContextAwareProcessor][Springboot_ApplicationContextAwareProcessor]

[Springboot扩展点之@PostConstruct][Springboot_PostConstruct]

[Springboot扩展点之InitializingBean][Springboot_InitializingBean]

[Springboot扩展点之SmartInitializingSingleton][Springboot_SmartInitializingSingleton]

[Springboot扩展点之CommandLineRunner和ApplicationRunner][Springboot_CommandLineRunner_ApplicationRunner]

[Springboot扩展点之FactoryBean][Springboot_FactoryBean]

[Springboot扩展点之DisposableBean][Springboot_DisposableBean]

[Springboot扩展点系列之终结篇：Bean的生命周期][Springboot_Bean]

![4984d3aa783c4164b55792a411405d5c.png][]

## **1.功能特性** ##

1.  BeanFactoryPostProcessor的执行是Spring Bean生命周期非常重要的一部分；

1.  BeanFactory级别的后置处理器，在Spring生命周期内，org.springframework.beans.factory.config.BeanFactoryPostProcessor\#postProcessBeanFactory只会执行一次；

1.  允许在容器读取到Bean的BeanDefinition数据之后，bean未实例化前，读取BeanDefiniion数据，并且可以根据需要进行修改；

## **2.实现方式** ##

1.  定义一个Dog类，name属性默认为“旺财”，颜色默认为“黑色”；

@Data
    @Component
    public class Dog {
        private String name="旺财";
        private String color="黑色";
    }

1.  定义一个实现类（MyBeanFactoryPostProcessor），实现org.springframework.beans.factory.config.BeanFactoryPostProcessor接口，重写postProcessBeanFactory()方法，并Dog类的属性name修改为“狗蛋”；并用@Component注解标记BeanFactoryPostProcessor接口的实现类（MyBeanFactoryPostProcessor）；

@Component
    @Slf4j
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            log.info("com.fanfu.config.MyBeanFactoryPostProcessor.postProcessBeanFactory被执行");
            ScannedGenericBeanDefinition dog = ((ScannedGenericBeanDefinition) beanFactory.getBeanDefinition("dog"))  ;
            MutablePropertyValues propertyValues = dog.getPropertyValues();
            propertyValues.addPropertyValue("name", "狗蛋儿");
            log.info("修改Dog的BeanDefinition对象中的name属性为狗蛋儿");
        }
    }

1.  编写单元测试验证结果；

@SpringBootTest
    @Slf4j
    public class FanfuApplicationTests {
        @Test
        public void test(){
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.fanfu");
            Dog dog = ((Dog) context.getBean("dog"));
            log.info(dog.getName());
            Assert.isTrue(dog.getName().equals("狗蛋儿"), "属性修改失败");
        }
    }

1.  验证结果表明，自定义的BeanFactoryPostProcessor接口的实现类（MyBeanFactoryPostProcessor），可以在容器读取到Bean的BeanDefinition数据之后，bean未实例化前，读取BeanDefiniion数据，并且根据需要进行修改，那么自定义的BeanFactoryPostProcessor接口的实现类（MyBeanFactoryPostProcessor）的工作原理是什么呢？BeanFactoryPostProcessor接口的实现类是什么时候实例化的？MyBeanFactoryPostProcessor\#postProcessBeanFactory方法是如何被调用的？接着往下看。

## **3.工作原理** ##

### **3.1BeanFactoryPostProcessor接口的实现类是什么时候实例化的？** ###

1.  BeanFactoryPostProcessor接口的实现类（MyBeanFactoryPostProcessor）被@Component标记，在窗口启动的时候会被封装成BeanDefinition对象注册到容器中；

![6d437b44d7a44f4b9beedfe8e64d62d8.png][]

1.  PostProcessorRegistrationDelegate\#invokeBeanFactoryPostProcessors()方法被执行时，会按照类型从Spring容器中找到所有BeanFactoryPostProcessor类型的实现类的名称；

![ea820b9de0954d61829d48e5c8263e0b.png][]

1.  在上一步中得到所有BeanFactoryPostProcessor类型的实现类的名称的名称后，再循环一次，来对BeanFactoryPostProcessor的实现类进行实例化 （beanFacotry.getBean()去获取MyBeanFactoryPostProcessor的实例，如果获取不到，就创建一个）；

![9a88b193970b4eff86585f1af57bcf2e.png][]

### **3.2MyBeanFactoryPostProcessor\#postProcessBeanFactory方法是如何被调用的？** ###

1.  在单元测试中构建了一个AnnotationConfigApplicationContext对象，AnnotationConfigApplicationContext的构造方法如下：

public AnnotationConfigApplicationContext(String... basePackages) {
       this();
       scan(basePackages);
       refresh();
    }

1.  从上面的AnnotationConfigApplicationContext的构造方法中，可以看到又调用了refresh()，这里实际最终被调用的是org.springframework.context.support.AbstractApplicationContext\#refresh()，这个方法也是Spring容器启动的关键方法，在分析Spring相关的源码时会经常碰到。

1.  AbstractApplicationContext\#refresh()中，调用org.springframework.context.support.AbstractApplicationContext\#invokeBeanFactoryPostProcessors方法才正式开始了BeanFactoryPostProcessor接口的所有实现类的postProcessBeanFactory()方法调用；

1.  跟着AbstractApplicationContext\#invokeBeanFactoryPostProcessors方法进去，会发现这里只是一个入口，实际承担调用执行任务的是org.springframework.context.support.PostProcessorRegistrationDelegate\#invokeBeanFactoryPostProcessors()方法；

1.  跟着PostProcessorRegistrationDelegate\#invokeBeanFactoryPostProcessors()方法进去后，会发现里面真的是别有洞天，很容易迷路（牢牢带着自己的问题分析源码找答案，不要被除自己问题以外的东西迷了眼，一定会柳暗花明），另外org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor的实现类的调用也在这个方法，所以这个方法的含金量很高，那就单独拎出来仔细分析一下，建议debug一步一步看，多看几遍就能明白，其实也很简单，唯一的难点就是这个方法有点长，需要多点耐心和时间。

public static void invokeBeanFactoryPostProcessors(
          ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
       //之所以说这个方法的含金量很高，
       //是因为在这个方法里是先执行BeanDefinitionRegistryPostProcessor实现类的postProcessBeanDefinitionRegistry方法； 
       //然后才接着执行BeanFactoryPostProcessor接口的实现类的postProcessBeanFactory方法
       //这两个接口很表面上看很类似，实际在执行的时机和功能上是有明显区别的
       Set<String> processedBeans = new HashSet<>();
       //AnnotationConfigApplicationContext继承于GenericApplicationContext，
       //而GenericApplicationContext又实现了BeanDefinitionRegistry接口
       //所以这里会进入if语句中
       if (beanFactory instanceof BeanDefinitionRegistry) {
          BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
          List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
          List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
            //这里提前执行的BeanFactoryPostProcessor，是在准备上下文环境时，发布了ApplicationPreparedEvent事件；
            //触发监听器，通过AbstractApplicationContext#addBeanFactoryPostProcessor注册进来的；
            //这里并不是这次要重点分析的内容，可以先跳过这； 
          for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
             if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                      (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
             }
             else {
                regularPostProcessors.add(postProcessor);
             }
          }
          List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
          // 从32行到72行，是在执行BeanDefinitionRegistryPostProcessor实现类的postProcessBeanDefinitionRegistry方法；
          //执行的过程也是有点小区折的，分三步，第一，执行实现了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);
             }
          }
          sortPostProcessors(currentRegistryProcessors, beanFactory);
          registryProcessors.addAll(currentRegistryProcessors);
          invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
          currentRegistryProcessors.clear();
          // 第二，执行实现了Ordered接口的实现类；
          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();
          //第三,执行剩下其他的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);
             currentRegistryProcessors.clear();
          }
          // BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，
          //所以这部分实现类的postProcessBeanFactory()会提前执行
          invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
          //第26行，非BeanDefinitionRegistryPostProcessor类型的BeanFactoryPostProcessor实现类会在这执行
          invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
       } else {
          invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
       }
       //BeanDefinitionRegistryPostProcessor接口的实现类上面已执行执行完了
       //下面开始准备执行BeanFactoryPostProcessor接口的实现类
       String[] postProcessorNames =
             beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
       // 正式执行前，把BeanFactoryPostProcessor接口的实现类分成了三类，
       //分别是实现了PriorityOrdered接口,实现了Ordered接口,其他;
       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
          }
          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接口的实现类； 
       sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
       invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
       // 第二，执行实现了Ordered接口的实现类； 
       List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
       for (String postProcessorName : orderedPostProcessorNames) {
          orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
       }
       sortPostProcessors(orderedPostProcessors, beanFactory);
       invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
       //第三，执行未实现上面两个接口的实现类，自定义的MyBeanFactoryPostProcessor就是在这里被执行的
       //其实，也很简单的，和BeanDefinitionRegistryPostProcessor接口的实现类的执行过程类似； 
       List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
       for (String postProcessorName : nonOrderedPostProcessorNames) {
          nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
       }
       invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
       beanFactory.clearMetadataCache();
    }

### **3.3调用时序图** ###

这里我画了一个时序图，可以更直观的看到整个调用过程，也可以照着这个图，一步一步debug来了解整个过程；

![e6e87feb05664971a6ec21a198378e1d.png][]

### **3.4postProcessBeanFactory()postProcessBeanDefinitionRegistry()** ###

通过分析PostProcessorRegistrationDelegate\#invokeBeanFactoryPostProcessors()方法，postProcessBeanFactory()与postProcessBeanDefinitionRegistry()的区别已经很明显了，这里再总结一下（总结的有不准的地方，还请小伙伴在评论区告诉我，一块进步）：

1.  BeanDefinitionRegistryPostProcessor接口的实现类的postProcessBeanDefinitionRegistry方法要优先于BeanFactoryPostProcessor接口的实现类的postProcessBeanFactory方法执行；

1.  postProcessBeanDefinitionRegistry方法形参是BeanDefinitionRegistry，postProcessBeanFactory方法的形参是ConfigurableListableBeanFactory，在功能上会有一些区别；需要注意的是DefaultListableBeanFactory实现了BeanDefinitionRegistry和ConfigurableListableBeanFactory接口；

1.  BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，关于BeanDefinitionRegistryPostProcessor可以移步这里：[Springboot扩展点之BeanDefinitionRegistryPostProcessor][Springboot_BeanDefinitionRegistryPostProcessor 1]；

## **4.应用场景** ##

对敏感信息的解密处理，比如数据库连接信息加密和解密：在实际的业务开发中，在配置文件中明文配置mysq，redis的密码实际上是不安全的，需要配置加密后的密码信息； 但是把加密后的密码信息注入的数据源中，去连接mysql数据库肯定会连接异常，因为mysql并不知道你的加密方式和加密方法。这就会产生一个需求：需要在配置文件中配置的数据库信息是加密的，但是在把密码信息注入数据源前在程序里解密处理。

BeanFactoryPostProcessor正好可以解决这个问题，在真正使用到数据源去连接数据库前，读取到加密信息，进行解密处理，再用解密后的信息替换掉Spring容器中加密信息。

[Springboot_ApplicationContextInitializer]: https://blog.csdn.net/fox9916/article/details/128522598
[Springboot_BeanFactoryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128823328
[Springboot_BeanDefinitionRegistryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128538625
[Springboot_BeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128917992
[Springboot_InstantiationAwareBeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128941464
[Springboot_SmartInstantiationAwareBeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128976944
[Springboot_ApplicationContextAwareProcessor]: https://blog.csdn.net/fox9916/article/details/128990305
[Springboot_PostConstruct]: https://blog.csdn.net/fox9916/article/details/128998846
[Springboot_InitializingBean]: https://blog.csdn.net/fox9916/article/details/129016083
[Springboot_SmartInitializingSingleton]: https://blog.csdn.net/fox9916/article/details/129042652
[Springboot_CommandLineRunner_ApplicationRunner]: https://blog.csdn.net/fox9916/article/details/129086542?spm=1001.2014.3001.5502
[Springboot_FactoryBean]: https://blog.csdn.net/fox9916/article/details/129070764?spm=1001.2014.3001.5502
[Springboot_DisposableBean]: https://blog.csdn.net/fox9916/article/details/129026156?spm=1001.2014.3001.5501
[Springboot_Bean]: https://blog.csdn.net/fox9916/article/details/129101918
[4984d3aa783c4164b55792a411405d5c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/2f3bc020e23a4e11b7b1954345199bbd.png
[6d437b44d7a44f4b9beedfe8e64d62d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a9f8b464b97d4da3815a8ff6d5bccebe.png
[ea820b9de0954d61829d48e5c8263e0b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ee3ff48e3656464c93ce58f35c8a7743.png
[9a88b193970b4eff86585f1af57bcf2e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/71883c2dae944fd0853024bfed421da4.png
[e6e87feb05664971a6ec21a198378e1d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/2e3c469564cc48fc8c3fbd83c8728527.png
[Springboot_BeanDefinitionRegistryPostProcessor 1]: https://blog.csdn.net/fox9916/article/details/128538625?spm=1001.2014.3001.5501