Spring 5.x 源码之旅-9invokeBeanFactoryPostProcessors二-CSDN博客

上一篇讲了是一次解析加载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");
        }
    }

结果：