Spring5 源码阅读笔记（1.2） invokeBeanFactoryPostProcessors(beanFactory) 调用Bean工厂后置处理器

在 refresh() 方法里，invokeBeanFactoryPostProcessors(beanFactory) 是第二个非常重要的方法。
从它的字面意思上看，它的作用是：调用 Bean 工厂的一些后置处理器。

其中有个很重要的子接口 BeanDefinitionRegistryPostProcessor。

什么是 Bean 工厂后置处理器呢？
顾名思义，在创建了 Bean 工厂后，可以对 Bean 工厂进行处理。我们可以自己定义处理器来添加或修改BeanDefinition，甚至提前获取实例。

我们先从示例来看看，怎么间接的用到这个方法：

@Component
public class BeanDefinitionTest implements BeanDefinitionRegistryPostProcessor {

  @Override
   public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
       GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
       genericBeanDefinition.setBeanClass(BeanClass.class);

//        genericBeanDefinition.getConstructorArgumentValues().addGenericArgumentValue(null);

       MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
       propertyValues.addPropertyValue("username","Peter");

       registry.registerBeanDefinition("beanClass",genericBeanDefinition);
   }

   @Override
   public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

   }
}

需要注意的几点：

1. 你要加上@Component，让这个类被解析成BeanDefinition
2. 必须实现BeanFactoryPostProcessor接口，这一点看我们今天的主角invokeBeanFactoryPostProcessors(beanFactory) 也知道
3. 示例中实现的BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口

@FunctionalInterface
public interface BeanFactoryPostProcessor {
	//在应用程序上下文的标准初始化之后修改它的内部bean工厂。
	//所有BeanDefinition都已加载，但还没有实例化Bean。
	//这个方法允许覆盖或添加属性，甚至是对急于初始化的Bean。（记住这个作用）
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
	//在应用程序上下文的标准初始化之后修改它的内部BeanDefinition注册表。
	//所有常规bean定义都已加载，但还没有实例化任何bean。
	//这个方法允许在下一个后处理阶段开始之前添加更多的BeanDefinition。（记住这个作用）
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

4. 示例这个类就是在invokeBeanFactoryPostProcessors(beanFactory)方法中被调用的。

接下来跟源码：
类 AbstractApplicationContext，和 refresh() 在一个类里

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

	// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
	// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
	if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
}

跟 invokeBeanFactoryPostProcessors：
类 PostProcessorRegistrationDelegate

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

	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	Set<String> processedBeans = new HashSet<>();

	//注意这里的BeanDefinitionRegistry
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		//不用看，基本不会到这里来
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		// Separate between BeanDefinitionRegistryPostProcessors that implement
		// PriorityOrdered, Ordered, and the rest.
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();


		//首先，调用实现了PriorityOrdered接口的所有BeanDefinitionRegistryPostProcessor(这也是个BeanDefinition)
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			//重要程度：1 判断是否实现了排序接口 PriorityOrdered
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				//注意这里：getBean是实例化过程，这里getBean说明对BeanDefinitionRegistryPostProcessor
				// 这种BeanDefinition是优先实例化的
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				//将实现了PriorityOrdered接口的name放入processedBeans
				processedBeans.add(ppName);
			}
		}

		//排序，为了按一定顺序调用
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);

		//调用过程
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();


		//然后，调用实现了Ordered接口的所有BeanDefinitionRegistryPostProcessor。
		//其实Ordered就是PriorityOrdered的父类。这两段代码的功能几乎一样。
		//但是从调用顺序上，所有实现了PriorityOrdered这个接口的会被实现了Ordered但没有实现
		//PriorityOrdered接口的优先调用。所以PriorityOrdered应该翻译成优先排序接口。
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			//如果没有实现PriorityOrdered但实现了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);
		currentRegistryProcessors.clear();

		// 最后，调用所有其它的BeanDefinitionRegistryPostProcessor
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//如果没有实现PriorityOrdered和Ordered
				if (!processedBeans.contains(ppName)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					reiterate = true;
				}
			}
			//为什么还要sort呢？可能是为了代码好看？
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);

			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		//调用postProcessBeanFactory方法
		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	//获取实现了BeanFactoryPostProcessor接口的类，获取beanDefinition的名称
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above
		}
		//实现了PriorityOrdered接口的
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		//实现了Ordered接口的
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			//没实现接口的
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	//排序
	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

	//调用
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

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

	// Clear cached merged bean definitions since the post-processors might have
	// modified the original metadata, e.g. replacing placeholders in values...
	beanFactory.clearMetadataCache();
}