spring4.2.9 java项目环境下ioc源码分析 (十）——refresh之invokeBeanFactoryPostProcessors方法

invokeBeanFactoryPostProcessors执行BeanFactory后置处理器，当然前提是你已经在容器中注册过此处理器了。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	}

先看下getBeanFactoryPostProcessors方法，看似简单返回BeanFactoryPostProcessors，但是实际很有意思，这里返回的不是spring容器中的BeanFactoryPostProcessors而是你手动注册的，什么是手动注册？你调用set方法把自己写的BeanFactoryPostProcessor类set进去，就可以用，不需要加注解或者是在xml中配置就可以执行。

PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors代码非常之多但是逻辑还是很简单的，下面先说下逻辑。

1、如果存在自己手动注册的BeanFactoryPostProcessor先执行自己的。但是也还是有先后顺序，先去执行类型为BeanDefinitionRegistryPostProcessor的后置处理器的postProcessBeanDefinitionRegistry方法（按手动注册顺序执行）。并且分别缓存BeanDefinitionRegistryPostProcessor类型的处理器和BeanFactoryPostProcessor类型的处理器。

2、执行完手动注册的BeanDefinitionRegistryPostProcessor后，查找spring容器中的所有注册了的BeanDefinitionRegistryPostProcessor后置处理器，优先执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法（按顺序），再去执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法（按顺序），最后执行没有实现两种接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法。同时缓存BeanDefinitionRegistryPostProcessor类型的处理器。

3、执行完上一步骤后，再去执行存储BeanDefinitionRegistryPostProcessor的缓存中BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法。再去执行在第一步中存储BeanFactoryPostProcessor的缓存中BeanFactoryPostProcessor的postProcessBeanFactory。

4、然后开始查找spring容器中的所有注册了的BeanFactoryPostProcessor，同样先去执行实现了PriorityOrdered接口的postProcessBeanFactory放在，再去执行实现了Ordered接口的。最后执行两个接口都没实现的。

上面内容涉及到了四个接口和两个方法。

Ordered与PriorityOrdered接口是用来判断后置处理器执行的先后顺序的，但是PriorityOrdered的优先级比Ordered高，所以实现PriorityOrdered接口类的优先执行。

BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口，其中BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口。BeanDefinitionRegistryPostProcessor的可以自定义BeanDefinition并注册进容器中，同样也具有BeanFactoryPostProcessor的功能进行beanFactory的修改。

postProcessBeanDefinitionRegistry和postProcessBeanFactory方法。两者都存在于BeanDefinitionRegistryPostProcessor接口中，表明其既可以自定义BeanDefinition并注册进容器中也可以对beanFactory的修改。而postProcessBeanFactory方法只存在与BeanFactoryPostProcessor。

好了宏观上了解了，那为什么逻辑要先执行postProcessBeanDefinitionRegistry然后在执行postProcessBeanFactory呢？

因为postProcessBeanDefinitionRegistry是用来创建bean定义的，而postProcessBeanFactory是修改BeanFactory，当然postProcessBeanFactory也可以修改bean定义的。为了保证在修改之前所有的bean定义的都存在，所以优先执行postProcessBeanDefinitionRegistry。如不是以上顺序，会出先再修改某个bean定义的报错，因为此bean定义的还没有被创建。

注：代码中多次出现beanFactory.getBean,这里是获取类的实例，后面会有单独的章节去讲，这里不做深究。只要知道返回的是类的实例即可。

下面来看代码

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {


		Set<String> processedBeans = new HashSet<String>();
		//先判断beanFactory是不是BeanDefinitionRegistry类型，这里的beanFactory
		//是DefaultListableBeanFactory类型实现了BeanDefinitionRegistry接口
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			//regularPostProcessors用来存储BeanFactoryPostProcessor类型
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
			//用来存储BeanDefinitionRegistryPostProcessor类型
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
					new LinkedList<BeanDefinitionRegistryPostProcessor>();
			//这里遍历手动注册的BeanFactoryPostProcessor
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				//是否是BeanDefinitionRegistryPostProcessor
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					//先去执行postProcessBeanDefinitionRegistry方法
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					//缓存起来
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
					//如果不是BeanDefinitionRegistryPostProcessor类型直接缓存
					regularPostProcessors.add(postProcessor);
				}
			}

			//在spring容器中得到BeanDefinitionRegistryPostProcessor类型的postProcessorName
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

			//存储实现了priorityOrdered接口的类
			List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				//如果确实实现了PriorityOrdered接口
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					//写入存储器
					priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//存储name表示已经执行
					processedBeans.add(ppName);
				}
			}
			//排序
			sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
			//registryPostProcessors中存储所有的priorityOrderedPostProcessors
			registryPostProcessors.addAll(priorityOrderedPostProcessors);
			//执行
			invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

			
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			//存储实现了Ordered接口的类
			List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				//processedBeans不包括表示没有执行并且确实实现了Ordered
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					//存储
					orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//存储name表示已经执行
					processedBeans.add(ppName);
				}
			}
			//三步，排序，存储，执行
			sortPostProcessors(beanFactory, orderedPostProcessors);
			registryPostProcessors.addAll(orderedPostProcessors);
			invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);

			//下面是既没有实现Ordered接口也没有实现PriorityOrdered接口的逻辑
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
						registryPostProcessors.add(pp);
						processedBeans.add(ppName);
						pp.postProcessBeanDefinitionRegistry(registry);
						reiterate = true;
					}
				}
			}

			//执行registryPostProcessors中对象的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			//执行regularPostProcessors中对象的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		//在spring容器中得到BeanFactoryPostProcessor类型的postProcessorName
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		//和BeanDefinitionRegistryPostProcessor逻辑一样这里不多说
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

	
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		
		beanFactory.clearMetadataCache();
	}

至此，注册新的Bean定义也好，修改也罢，都完成了。