Spring源码学习：BeanFactoryPostProcessor学习

BeanFactoryPostProcessor

1 简介

该接口主要作用在spring读取或扫描bean定义后，bean实例化之前对beanDefinition进行一些操作，比如更改bean的类型（单例或者原型）

2 源码学习

2.1 自定义一个BeanFactoryPostProcessor

@Component
public class MyBeanFatoryPostProcessor implements BeanFactoryPostProcessor {
	//实现接口中唯一方法
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        String[] beanDefinitionNames = configurableListableBeanFactory.getBeanDefinitionNames();
        System.out.println("测试" + beanDefinitionNames.length + "测试");
    }
}

2.2 AnnotationConfigApplicationContext

进入到refresh方法中

...
//获取beanFactory实例，并初始化一些操作
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                //处理BeanFactoryPostProcessor主要方法
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //注册BeanPostProcessor主要方法
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();

进入方法invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//主要处理逻辑，其中this.getBeanFactoryPostProcessors()返回this.beanFactoryPostProcessors，此时size为0
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
        if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

    }

invokeBeanFactoryPostProcessors：对BeanFactoryPostProcessor的核心处理

    public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        Set<String> processedBeans = new HashSet();
        ArrayList regularPostProcessors;
        ArrayList registryProcessors;
        int var9;
        ArrayList currentRegistryProcessors;
        String[] postProcessorNames;
        //此处beanFactory为DefaultListableBeanFactory，实现了接口BeanDefinitionRegistry
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
            regularPostProcessors = new ArrayList();
            registryProcessors = new ArrayList();
            Iterator var6 = beanFactoryPostProcessors.iterator();
			//此处不进入while循环
            while(var6.hasNext()) {
                BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                } else {
                    regularPostProcessors.add(postProcessor);
                }
            }

            currentRegistryProcessors = new ArrayList();
            //获取符合BeanDefinitionRegistryPostProcessor的bean名字，此时只有org.springframework.context.annotation.internalConfigurationAnnotationProcessor
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            int var10;
            String ppName;
            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                //判断继承优先级排序接口
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                	//此处会创建真正的实例ConfigurationClassPostProcessor
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    //执行过的处理器bean缓存
                    processedBeans.add(ppName);
                }
            }
			//处理器进行排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            //执行真正的处理方法，此时只会执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry（如果我们没有在上下文初始化中注册额外的处理器），该方法会调用ConfigurationClassParser的parse方法解析我们各种注解的各种bean
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            //执行后清空处理器
            currentRegistryProcessors.clear();
            //再次执行获取BeanDefinitionRegistryPostProcessor，主要是通过上述执行ConfigurationClassPostProcessor方法，可能会获取我们的自定义的BeanDefinitionRegistryPostProcessor，所以需要再次扫描，具体过程同上一致
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                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, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
            //重复执行注册处理器flag
            boolean reiterate = true;
			//再次判断上述执行过程中新添加的BeanDefinitionRegistryPostProcessor，
            while(reiterate) {
                reiterate = false;
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                String[] var19 = postProcessorNames;
                var10 = postProcessorNames.length;

                for(int var26 = 0; var26 < var10; ++var26) {
                    String ppName = var19[var26];
                    //如果缓存不包括说明是新获取的BeanDefinitionRegistryPostProcessor
                    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, beanFactory.getApplicationStartup());
                currentRegistryProcessors.clear();
            }
			//跳出循环后执行剩余的处理器
            invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
            invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        } else {
            invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        }
		//获取BeanFactoryPostProcessor名字，包括我们自定义的
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
        regularPostProcessors = new ArrayList();
        registryProcessors = new ArrayList();
        currentRegistryProcessors = new ArrayList();
        postProcessorNames = postProcessorNames;
        int var20 = postProcessorNames.length;

        String ppName;
        for(var9 = 0; var9 < var20; ++var9) {
            ppName = postProcessorNames[var9];
            if (!processedBeans.contains(ppName)) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    registryProcessors.add(ppName);
                } else {
                    currentRegistryProcessors.add(ppName);
                }
            }
        }

        sortPostProcessors(regularPostProcessors, beanFactory);
        //执行实现PriorityOrdered接口的regularPostProcessors处理器
        invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(registryProcessors.size());
        Iterator var21 = registryProcessors.iterator();

        while(var21.hasNext()) {
            String postProcessorName = (String)var21.next();
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }

        sortPostProcessors(orderedPostProcessors, beanFactory);
        //执行实现Ordered接口的orderedPostProcessors处理器
        invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());
        Iterator var24 = currentRegistryProcessors.iterator();

        while(var24.hasNext()) {
            ppName = (String)var24.next();
            nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
		//执行剩下的普通处理器
        invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        beanFactory.clearMetadataCache();
    }

3 源码实例：ConfigurationClassPostProcessor

3.1 类继承图

ConfigurationClassPostProcessor配置类处理器，从图可以看出改类继承了排序接口，可以对多个处理器的执行顺序按照需求进行自定义，同时继承了多个Aware接口，可以感知资源加载器，环境beanClassLoader等内容，最重要的继承了BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor,也即实现了对应的方法postProcessBeanDefinitionRegistry

3.2 主要功能

postProcessBeanDefinitionRegistry主要逻辑

@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		//通过获取对象hashcode判断是否处理过该后置处理器
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);

		//处理配置类
		processConfigBeanDefinitions(registry);
	}

主要是通过调用processConfigBeanDefinitions处理配置类，该方法主要是对我们的配置类各种注解bean进行处理，转换为ConfigurationClass，最后会注册到工厂缓存beanDefinitionMap中，后续进行实例化。
postProcessBeanFactory主要逻辑

@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		int factoryId = System.identityHashCode(beanFactory);
		if (this.factoriesPostProcessed.contains(factoryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + beanFactory);
		}
		this.factoriesPostProcessed.add(factoryId);
		if (!this.registriesPostProcessed.contains(factoryId)) {
			// BeanDefinitionRegistryPostProcessor hook apparently not supported...
			// Simply call processConfigurationClasses lazily at this point then.
			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
		}
		//增强@Configuration全注解类
		enhanceConfigurationClasses(beanFactory);
		//添加后置处理器处理实现ImportAware的bean
		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
	}

该方法主要是对全注解类@Configuration修饰的类进行增强，该类中@Bean修饰的方法调用时不会直接调用该方法，而是使用子类覆盖的方法处理。同时添加后置处理器对实现ImportAware的类进行初始化前处理：设置导入类的注解元数据。