- PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors
-
- 大致的执行流程
- 定义处理器集合
-
- BeanFactoryPostProcessor接口
- BeanDefinitionRegistryPostProcessor接口
- 执行扩展的BeanFactoryPostProcessor
-
- 扩展例子实战一
- 创建BeanDefinitionRegistryPostProcessor类型的处理器
-
- getBeanNamesForType根据类型获取bean名字
-
- doGetBeanNamesForType
- 扩展例子实战二
-
- TestBeanDefinitionRegistryPostProcessorPriorityOrdered
- 将创建出来的处理器排序，准备处理
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后置处理器的处理过程。
好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。