- ConfigurationClassParser加载bean定义还有一点尾巴
-
- 循环解析加载bean定义
- 注册单例importStack
- 清除字节码元数据缓存
- BeanDefinitionRegistryPostProcessor后置处理器处理流程
- 处理一般排序的BeanDefinitionRegistryPostProcessor后置处理器
-
- 扩展点实战一
-
- 注意
- 循环处理最后剩下的BeanDefinitionRegistryPostProcessor后置处理器
-
- 扩展点实战二
-
- 扩展点顺序
-
- 注意
ConfigurationClassParser加载bean定义还有一点尾巴
循环解析加载bean定义
上一篇讲了是一次解析加载bean定义的过程，其实外面是个循环，因为你加载了bean定义后，可能会有新的配置类的bean定义，所以也要进行解析和加载bean，因此是一个循环。我省略了部分代码，把主要的循环流程和判断留下来了。其实就是循环处理新加载进来的配置类的bean定义，直到没有为止。
do {
//开始解析configCandidates元素
parser.parse(candidates);//解析配置类集合
parser.validate();//验证如果要CGLIB代理的话，条件是否满足，比如类不能final，bean注解
this.reader.loadBeanDefinitions(configClasses);//加载bean定义
...
if (registry.getBeanDefinitionCount() > candidateNames.length) {
//如果有加载到新的bean定义，再继续加载
...
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
//处理新的
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
//符合配置类要求就添加到candidates
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;//更新候选名字
}
}
while (!candidates.isEmpty());
注册单例importStack
把importStack注册为单例，为了支持ImportAware接口扩展，说明已经处理Import注解过了。
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
清除字节码元数据缓存
有些bean定义的元数据是通过URL加载字节码文件解析来的，为了避免每次都去IO操作，会有元数据的缓存，现在处理完了就要把缓存清除了。
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
BeanDefinitionRegistryPostProcessor后置处理器处理流程
处理一般排序的BeanDefinitionRegistryPostProcessor后置处理器
至此ConfigurationClassPostProcessor的处理完成了，也就是有优先级PriorityOrdered的后置处理器处理好了，现在要处理一般顺序Ordered的处理器了，这段代码跟前面的一样，只是这次是取一般顺序的处理器，执行的是一样的流程，这里还是再次获取BeanDefinitionRegistryPostProcessor类型的，会把所有的都获取出来，当然包括处理过的，不过没关系，处理过的处理器会放入processedBeans中，不会再次处理的：
//再次获取没处理过的BeanDefinitionRegistryPostProcessors且实现Ordered接口的来处理，因为可能前面处理后产生新的bean定义
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//没处理过的，而且是Ordered类型的
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);
其实这里也可能是PriorityOrdered类型的，是通过前面解析出来的。比如我们来看这个扩展点。
扩展点实战一
比如创建了一个TestBeanDefinitionRegistryPostProcessorPriorityOrdered 实现了BeanDefinitionRegistryPostProcessor和Ordered 。
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;
}
}
然后配置类里面用bean注解方法，直接返回这个实例类型，我这里为了方便，其实应该返回接口类型，另外写一个接口类型比较好的。
@Configuration
public class MyConfig {
@Bean
public TestBeanDefinitionRegistryPostProcessorPriorityOrdered myRegistrar(){
return new TestBeanDefinitionRegistryPostProcessorPriorityOrdered();
}
}
执行的结果就是会被创建出来，然后执行postProcessBeanDefinitionRegistry方法：
注意
这里要注意，这个时候因为要创建TestBeanDefinitionRegistryPostProcessorPriorityOrdered处理器，所以MyConfig也会被创建出来，作为单例。
循环处理最后剩下的BeanDefinitionRegistryPostProcessor后置处理器
最后就处理剩下的那些后置处理器，比如我在前面的扩展点再注册bean定义。
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();
}
扩展点实战二
还是刚才的TestBeanDefinitionRegistryPostProcessorPriorityOrdered ，我在postProcessBeanDefinitionRegistry里自定义注册了一个bean定义TestBeanDefinitionRegistryPostProcessor。
他就会在最后被getBeanNamesForType找到执行。
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");
AnnotatedBeanDefinition genericBeanDefinition=new AnnotatedGenericBeanDefinition(TestBeanDefinitionRegistryPostProcessor.class);
registry.registerBeanDefinition("TestBeanDefinitionRegistryPostProcessor",genericBeanDefinition);
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyBeanDefinitionRegistryPostProcessorPriorityOrdered postProcessBeanFactory");
}
//排序的值，越小越前面
@Override
public int getOrder() {
return 1;
}
}
TestBeanDefinitionRegistryPostProcessor 也是BeanDefinitionRegistryPostProcessor 类型的，扩展方法里又注册了一个UserDaoImple。
public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("MyBeanDefinitionRegistryPostProcessor postProcessBeanDefinitionRegistry");
registry.registerBeanDefinition("UserDaoImple",new AnnotatedGenericBeanDefinition(UserDaoImple.class));
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyBeanDefinitionRegistryPostProcessor postProcessBeanFactory");
}
}
结果：
而且在里面又注册了一个UserDaoImple：
至此，所有实现的BeanDefinitionRegistryPostProcessor接口的处理器都处理完成了。
我们的自定义扩展顺序可以看这里：
扩展点顺序
ConfigurationClassPostProcessor处理MyConfig，MyConfig定义了TestBeanDefinitionRegistryPostProcessorPriorityOrdered的bean注解方法，可以被加载进bean定义。
TestBeanDefinitionRegistryPostProcessorPriorityOrdered的postProcessBeanDefinitionRegistry方法中注册了TestBeanDefinitionRegistryPostProcessor的bean定义。
TestBeanDefinitionRegistryPostProcessor中的postProcessBeanDefinitionRegistry又注册了UserDaoImple的bean定义。
注意
这个时候你会发现创建处理器的同时把配置类也创建了。
至此BeanDefinitionRegistryPostProcessor的处理器全部处理完成，包括自定义的。后面就要处理BeanFactoryPostProcessor的处理器啦，这个后面讲。
好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。