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

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后置处理器的处理过程。

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。