Springboot扩展点之BeanDefinitionRegistryPostProcessor

ゞ浴缸里的玫瑰 2024-03-30 14:14 9阅读 0赞

![14553973f4d842ceb2e98ce9dd4a833f.png][]

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]

--------------------

## **前言** ##

通过这篇文章来大家分享一下，另外一个Springboot的扩展点BeanDefinitionRegistryPostProcessor，一般称这类扩展点为容器级后置处理器，另外一类是Bean级的后置处理器；容器级的后置处理器会在Spring容器初始化后、刷新前这个时间执行一次，Bean级的重置处理器，则是在每一个Bean实例化前后都会执行。

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

1.  postProcessBeanDefinitionRegistry()方法可以通过BeanDefinitionRegistry对BeanDefintion进行增删改查；

1.  继承了BeanFactoryPostProcessor，BeanFactoryPostProcessor是容器级别的扩展接口，org.springframework.beans.factory.config.BeanFactoryPostProcessor\#postProcessBeanFactory方法在容器实例化后、刷新容器前被执行，即在容器刷新前还可以对BeanDefintion再作一些操作；

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
       void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
    }

@FunctionalInterface
    public interface BeanFactoryPostProcessor {
       void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    }

总结起来就是，在所有的BeanDefinition加载完成之后，Bean真正被实例化之前，可以通过实现BeanDefinitionRegistryPostProcessor接口，对BeanDefinition再做一些定制化的操作，比如修改某个bean的BeanDefinition的属性、手动注册一些复杂的Bean。

对于Spring原理不太熟悉的小伙伴心里看到这可能有点晕了，BeanDefinition是什么？BeanDefinitionRegistry又是什么？ConfigurableListableBeanFactory又又是什么？别着急，这里拐个弯简单的解释一下，对整篇文章的理解会更顺畅。

### **1.1 BeanDefinition** ###

大家都知道，Spring的核心之一是IOC（控制反转），Spring之所以可以实现bean控制权的反转，是因为Spring的容器功能，在bean纳入Spring容器管理前，所有bean会被抽象封装成一个BeanDefinition实例，然后会在不同的时机根据BeanDefinition实例信息对bean进行实例化。

简单说，Dog.java描述狗这一类动物的属性和行为，BeanDefinition描述Dog.java这个类。

### **1.2 BeanDefinitionRegistry** ###

BeanDefinitionRegistry从字面意思看是bean的定义信息的注册登记，其实这个类的功能和字面意思一样，就是对BeanDefinition进行管理（增删改查）；

public interface BeanDefinitionRegistry extends AliasRegistry {
        //注册beanDefinition
       void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
             throws BeanDefinitionStoreException;
        //移除指定的beanDefinition
       void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
        //根据beanName查询beanDefinition
       BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
        //判断某个beanDefinition是否已经注册
       boolean containsBeanDefinition(String beanName);
        //获取所有已注册的beanDefinition
       String[] getBeanDefinitionNames();
        //获取所有已注册的beanDefinition的数量
       int getBeanDefinitionCount();
        //判断某个beanDefinition是否已经被使用
       boolean isBeanNameInUse(String beanName);
    }

### **1.3 ConfigurableListableBeanFactory** ###

上面提到了Spring的容器，Spring的核心之一是IOC，那么Spring的容器设计就是核心中的核心了。Spring的容器有多种形态，最基础的形态就是BeanFactory，ConfigurableListableBeanFactory间接继承了BeanFactory，因此ConfigurableListableBeanFactory实现类除了有Spring基础版本容器的功能外，还有一些高级的功能，Springboot默认的实际实现是DefaultListableBeanFactory，有兴趣的小伙伴可以以此为入口深入探究一番，这里不展开细说了。

![210477dd95534d18aeefbf2185cae77a.png][]

## **2.自定义实现** ##

### **2.1 MyBeanDefinitionRegistryPostProcessor** ###

下面通过一个具体类MyBeanDefinitionRegistryPostProcessor实现BeanDefinitionRegistryPostProcessor接口，来探究BeanDefinitionRegistryPostProcessor实现类的初始化和执行过程。

1.  在postProcessBeanDefinitionRegistry()方法被调用的时候手工在Spring中注册了Dog类的BeanDefinition信息；

1.  在postProcessBeanFactory()方法被调用的时候，从Spring容器中取出Dog类的BeanDefinition信息和Dog类的实例；

@Data
    public class Dog {
        private String name;
        private String color;
    }

@Component
    public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            //手工定义一个beanDefinition实例
            RootBeanDefinition beanDefinition = new RootBeanDefinition();
            //给beanDefinition填充属性
            beanDefinition.setBeanClass(Dog.class);
            MutablePropertyValues propertyValues = new MutablePropertyValues();
            PropertyValue propertyValue1 = new PropertyValue("name", "旺财");
            PropertyValue propertyValue2 = new PropertyValue("color", "黑色");
            propertyValues.addPropertyValue(propertyValue1);
            propertyValues.addPropertyValue(propertyValue2);
            beanDefinition.setPropertyValues(propertyValues);
            //注册手工定义的beanDefinition
            registry.registerBeanDefinition("dog", beanDefinition);
        }
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("-----------start------------");
            //根据类名取出手工注册的beanDefinition
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition("dog");
            System.out.println(beanDefinition.getBeanClassName());
            //根据类从容器中取出手工注册的beanDefinition所描述的实例bean
            Dog dog = beanFactory.getBean(Dog.class);
            System.out.println(dog.getName());
            System.out.println(dog.getColor());
            System.out.println("-----------end------------");
        }
    }

单元测试

@Test
    public void test(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.fanfu");
        Dog dog = ((Dog) context.getBean("dog"));
        System.out.println(dog.getName());
        System.out.println(dog.getColor());
    }

### **2.2 UML类图** ###

通过BeanDefinitionRegistryPostProcessorUML类图可以看出BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，postProcessBeanDefinitionRegistry()方法属于BeanDefinitionRegistryPostProcessor，postProcessBeanFactory()属于BeanFactoryPostProcessor，所有实现了BeanDefinitionRegistryPostProcessor接口的实现类都需要实现这两个方法，而作为Springboot的扩展点之一，其扩展的逻辑也在这两个方法中。

![3d005e3d44d34c06aeedb80ce60f8dc1.png][]

## **3. 初始化和执行时机** ##

通过自定义的MyBeanDefinitionRegistryPostProcessor类，实现BeanDefinitionRegistryPostProcessor接口，从项目启动开始，其执行过程如下：

1.  执行项目的主类，org.springframework.boot.SpringApplication\#run被调用；

1.  进入boot.SpringApplication\#run方法后，刚开始是一些Spring容器初始化的配置操作，直到执行到org.springframework.boot.SpringApplication\#refreshContext，开始容器刷新，进入了关键阶段；

1.  在SpringApplication\#refreshContext，实际的刷新逻辑是在org.springframework.context.support.AbstractApplicationContext\#refresh方法中；

1.  AbstractApplicationContext\#refresh方法中，调用org.springframework.context.support.AbstractApplicationContext\#invokeBeanFactoryPostProcessors开始初始化和执行实现BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry()和postProcessBeanFactory()；

1.  进入AbstractApplicationContext\#invokeBeanFactoryPostProcessors方法，发现又调用了org.springframework.context.support.PostProcessorRegistrationDelegate\#invokeBeanFactoryPostProcessors()；

1.  在PostProcessorRegistrationDelegate\#invokeBeanFactoryPostProcessors()方法中，并不是直接就初始化和执行postProcessBeanDefinitionRegistry()和postProcessBeanFactory()，而是又进行了一系列的判断，其判断顺序是：1、通过AbstractApplicationContext\#addBeanFactoryPostProcessor提前注册的BeanDefinitionRegistryPostProcessor实现类；2、实现了PriorityOrdered接口；3、是否实现了Ordered；4、剩下的其他BeanDefinitionRegistryPostProcessor实现类；自定义的MyBeanDefinitionRegistryPostProcessor就属于第4类，所以是所有实现里较晚才被执行的，如果想要提前被执行，可以考虑前面三种方式；

1.  在PostProcessorRegistrationDelegate\#invokeBeanFactoryPostProcessors()方法中执行完MyBeanDefinitionRegistryPostProcessor\#postProcessBeanDefinitionRegistry方法后，紧接着就开始执行MyBeanDefinitionRegistryPostProcessor\#postProcessBeanFactory方法了；从整个调用过程看postProcessBeanDefinitionRegistry()是早于postProcessBeanFactory()方法执行；

下面是我根据整个调用过程画的一个时序图，过程确实比较复杂，但是逻辑比较清晰，因此并不难理解，想要真的搞清楚整个过程，最好的方法就是照着这个图，亲自执行一遍，通过debug观察每一个关键节点的执行过程。

![5e70bcb4ff1d43b19da823fbc6e2a6d9.png][]

## **4. 内部实现类** ##

spring-boot-starter-web中内置的实现类有CachingMetadataReaderFactoryPostProcessor、ConfigurationClassPostProcessor、ConfigurationWarningsPostProcessor、EmbeddedDataSourceBeanFactoryPostProcessor、ImportsCleanupPostProcessor、TestRestTemplateRegistrar、WebTestClientRegistrar、WsdlDefinitionBeanFactoryPostProcessor，观察一下每个实现类会发现：都比较类似，这些内置实现类都是Springboot中的内部类，通过这些BeanDefinitionRegistryPostProcessor内部实现类向Spring容器中注册了一些特殊的BeanDefinition，如果展开详细再说一说这些Bean，怕是一天一夜也说不完，有兴趣的小伙伴可以深入了解一下，这里就不再展开了。

## **5. 总结** ##

通过梳理整个过程，其实最关键的就是一句话：在Spring容器初始后、未刷新前，即Bean已被扫描注册为BeanDefinition后，未正式实例化前，可以通过实现BeanDefinitionRegistryPostProcessor做一些额外的操作。

[14553973f4d842ceb2e98ce9dd4a833f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/125fb05c135e4b2eaa4227eaf1a35efa.png
[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
[210477dd95534d18aeefbf2185cae77a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7ea89a1fa6044d89b42e511da4300b42.png
[3d005e3d44d34c06aeedb80ce60f8dc1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e366f944218942489e05a56186fd1eeb.png
[5e70bcb4ff1d43b19da823fbc6e2a6d9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/aba35e359d62474490e54b786b94de7e.png