Spring 5.x 源码之旅-5invokeBeanFactoryPostProcessors一以及扩展点

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors

大致的执行流程

内部处理都是让PostProcessorRegistrationDelegate代理的。这个方法比较长，也比较复杂，我们可以分段来分析。首先会定义一个名字集合，表示处理过的处理器名字集合。

    Set<String> processedBeans = new HashSet<>();//处理过的BeanDefinitionRegistryPostProcessors类型的bean名字集合

定义处理器集合

首先会先定义两个处理器集合，一个是BeanFactoryPostProcessor类型的，一个是BeanDefinitionRegistryPostProcessor类型的。

    List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();//BeanFactoryPostProcessor类型的
    List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();//BeanDefinitionRegistryPostProcessor类型的

其实这个两个是继承关系，我们来看看：

BeanFactoryPostProcessor接口

这个接口可以扩展，可以对beanFactory做处理，也就是在后置处理器最开始的时候，先处理自定义的处理器。

    @FunctionalInterface
    public interface BeanFactoryPostProcessor {
    
    	/** 可以操作beanFactory
    	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    
    }

BeanDefinitionRegistryPostProcessor接口

继承了BeanFactoryPostProcessor接口，增加了新方法，把注册器暴露出来了，更大的扩展。

    public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    
    	//可以操作BeanDefinitionRegistry 
    	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
    
    }

执行扩展的BeanFactoryPostProcessor

这里的beanFactoryPostProcessors是外面传进来的，默认是空的，除非你自己扩展了。

    //先处理BeanDefinitionRegistryPostProcessor，因为这里可以自定义扩展，增加bean定义
    			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {//先处理自定义的BeanDefinitionRegistryPostProcessor
    				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
    					BeanDefinitionRegistryPostProcessor registryProcessor =
    							(BeanDefinitionRegistryPostProcessor) postProcessor;
    					registryProcessor.postProcessBeanDefinitionRegistry(registry);//执行扩展方法
    					registryProcessors.add(registryProcessor);
    				}
    				else {
    					regularPostProcessors.add(postProcessor);
    				}
    			}

扩展例子实战一

我们来看下这里第一个扩展是怎么样的，举个例子。
我创建了一个后置处理器TestBeanDefinitionRegistryPostProcessor 实现了BeanDefinitionRegistryPostProcessor 接口。

    public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessor postProcessBeanDefinitionRegistry");
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessor postProcessBeanFactory");
        }
    }

我们的测试就要这样写：
需要在refresh之前把扩展的实例加进去addBeanFactoryPostProcessor。

        @Test
        public void BeanDefinitionRegistryPostProcessorTest0() {
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
            applicationContext.register(MyConfig.class);
            applicationContext.addBeanFactoryPostProcessor(new TestBeanDefinitionRegistryPostProcessor());
            applicationContext.refresh();
        }

结果里面就有刚才放进去的TestBeanDefinitionRegistryPostProcessor：

可以看到会抵用这个方法，你可以进行扩展：

创建BeanDefinitionRegistryPostProcessor类型的处理器

这个也就是获取创建的时候内部添加的BeanDefinitionRegistryPostProcessor后置处理器，其实就是从bean工厂的beanDefinitionNames里获取相应的名字，然后先创建PriorityOrdered优先排序的处理器，放入currentRegistryProcessors集合里。名字放入最开始的processedBeans中，表示处理过了。

    	List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();//放内部的BeanDefinitionRegistryPostProcessor后置处理器
    	
    	String[] postProcessorNames =//获取BeanDefinitionRegistryPostProcessor类型对应的bean的名字
    			beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    	for (String ppName : postProcessorNames) {//只处理PriorityOrdered类型的
    		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    			currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));//先创建ConfigurationClassPostProcessor
    			processedBeans.add(ppName);
    		}
    	}

getBeanNamesForType根据类型获取bean名字

实际上开始就只执行到这里，调用doGetBeanNamesForType来返回。

    @Override
    	public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
    		if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
    			return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
    		}
    		...

doGetBeanNamesForType

里面分两部分，一部分是从定义的bean名字列表中查找，另一部分是从预处理注册的单例中查找。具体里面很复杂，咱是不讲，后面会详细讲。
这里如果没有扩展的话，就是获取org.springframework.context.annotation.internalConfigurationAnnotationProcessor，对应的类就是ConfigurationClassPostProcessor。
我们可以来看看：

但是这里是可以扩展的。

扩展例子实战二

其实就是用上面扩展例子，只是TestBeanDefinitionRegistryPostProcessor 变成这样，直接在registry中添加bean定义，把BeanDefinitionRegistryPostProcessor和PriorityOrdered接口的类型注册进去，在最开始的地方就可以把自己定义的TestBeanDefinitionRegistryPostProcessorPriorityOrdered类注册进去：

    public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessor postProcessBeanDefinitionRegistry");
            registry.registerBeanDefinition("mytest",new AnnotatedGenericBeanDefinition(TestBeanDefinitionRegistryPostProcessorPriorityOrdered.class));
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessor postProcessBeanFactory");
        }
    }

TestBeanDefinitionRegistryPostProcessorPriorityOrdered

实现了BeanDefinitionRegistryPostProcessor和PriorityOrdered 接口。

    public class TestBeanDefinitionRegistryPostProcessorPriorityOrdered implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {
        public TestBeanDefinitionRegistryPostProcessorPriorityOrdered(){
            System.out.println("TestBeanDefinitionRegistryPostProcessorPriorityOrdered被创建了");
        }
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessorPriorityOrdered postProcessBeanDefinitionRegistry");
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessorPriorityOrdered postProcessBeanFactory");
        }
        //排序的值，越小越前面
        @Override
        public int getOrder() {
            return 1;
        }
    }

可以看到我们自己注册的也获取了。

然后被创建出来了，我们扩展的类和内部的后置处理器一起创建了：

将创建出来的处理器排序，准备处理

前面我们已经将BeanDefinitionRegistryPostProcessor类型，且是PriorityOrdered优先级的创建出来了，里面还能自己扩展，然后要进行排序，因为有多个，这样可以调整顺序，很灵活，内部的ConfigurationClassPostProcessor默认是优先级最低的Ordered.LOWEST_PRECEDENCE。

    sortPostProcessors(currentRegistryProcessors, beanFactory);//排序，有自定义的处理器可以控制执行顺序
    			registryProcessors.addAll(currentRegistryProcessors);//合并自定义的和spring内部的
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);//处理bean定义注册后置处理器

这里还会进行已注册的处理器的合并，一个是我们自己创建添加进去的，一个是扩展方法注册bean定义进去的：

好像有点长了，后面我们再继续讲invokeBeanDefinitionRegistryPostProcessors后置处理器的处理过程。