spring5.0 源码解析（day03） invokeBeanFactoryPostProcessors(beanFactory)；

invokeBeanFactoryPostProcessors

直译过来是调用 BeanFactory 的后置处理器 ， 这些后置处理器是bean在定义中向容器注册的

BeanFactoryPostProcessors 也是beanfactory的一个扩展点
本方法会实例化和调用所有 BeanFactoryPostProcessor（包括其子类 BeanDefinitionRegistryPostProcessor）。

// 委托 AbstractApplicationContext 的后处理器处理。
		// 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors变量中的值
		// 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的BeanFactoryPostProcessor
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// 检测 LoadTimeWeaver 并准备编织，
		// 如果同时发现（例如，通过 ConfigurationClassPostProcessor 注册的 @Bean 方法）

		if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

我们可以实现 BeanFactoryPostProcessor接口 ，重写postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
接口来实现对 beanFactory的扩展操作

@Component
public class MyBeanFactoryPostProcessors implements BeanFactoryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		BeanDefinition daoService = beanFactory.getBeanDefinition("daoServiceImpl");
		// 设置 daoService 为懒加载
		daoService.setLazyInit(false);
		System.out.printf(daoService.getBeanClassName());
	}
}

debug中可以看得到 daoServiceImpl 的 lazyInit 属性 变成了 false

invokeBeanFactoryPostProcessors

整个 invokeBeanFactoryPostProcessors 方法操作了 3 种 bean 对象 入参 beanFactoryPostProcessors 和 BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 的子类

该方法执行分以下几步

1. 入参 beanFactoryPostProcessors 中的 BeanDefinitionRegistryPostProcessor， 调用 postProcessBeanDefinitionRegistry 方法直接执行
2. 扫描全部 BeanDefinitionRegistryPostProcessor 类类型的bean 根据 实现的 PriorityOrdered 接口 按照优先级排序一次执行 ，注意没有实现接口的在这一步骤还没有执行
3. 扫描全部 BeanDefinitionRegistryPostProcessor 类类型的bean 根据 实现的 Ordered接口 按照优先级排序一次执行 ，注意没有实现接口的在这一步骤还没有执行
4. 执行扫描到所有剩余 BeanDefinitionRegistryPostProcessors
5. 最后调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
6. 入参 beanFactoryPostProcessors 中的常规 BeanFactoryPostProcessor，调用 postProcessBeanFactory 方法
7. 扫描 BeanFactoryPostProcessor 接口实现类，并且实现了 PriorityOrdered 接口，调用 postProcessBeanFactory 方法
8. 扫描 BeanFactoryPostProcessor 接口实现类，并且实现了 Ordered接口，调用 postProcessBeanFactory 方法
9. 调用剩余BeanFactoryPostProcessor 的 postProcessBeanFactory 方法

BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor 的子类，如果 他们俩的子类

/**
		 * 警告：虽然看起来这个方法的主体可以很容易地重构以避免使用多个循环和多个列表，
		 * 但使用多个列表和多次遍历处理器名称是有意的。
		 * 我们必须确保遵守 PriorityOrdered 和 Ordered 处理器的合同。
		 * 具体来说，我们不能导致处理器被实例化（通过 getBean() 调用）或以错误的顺序在 ApplicationContext 中注册。
		 * 在提交更改此方法的拉取请求 (PR) 之前，
		 * 请查看所有涉及更改 PostProcessorRegistrationDelegate 的拒绝 PR 的列表，
		 * 以确保您的提案不会导致重大更改：
		 */
// 存储  processedBeans
		Set<String> processedBeans = new HashSet<>();

		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			// 保存 常规后置处理器
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			// 保存 注册处理器
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			// 遍历 处理器
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				// 将BeanDefinitionRegistryPostProcessor和普通BeanFactoryPostProcessor区分开
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					// 直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			//不要在此处初始化 FactoryBeans：我们需要保留所有常规 bean 未初始化，
			//以便让 bean 工厂后处理器应用于它们！
			//将实现 PriorityOrdered、Ordered 和其余部分的 BeanDefinitionRegistryPostProcessor 分开。

			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// 首先，调用实现 PriorityOrdered 的 BeanDefinitionRegistryPostProcessors.
			// 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

			for (String ppName : postProcessorNames) {
				// 校验是否实现了PriorityOrdered接口  (优先排序)
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					// 获取ppName对应的bean实例, 添加到currentRegistryProcessors中
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					// 将要被执行的加入processedBeans，避免后续重复执行
					processedBeans.add(ppName);
				}
			}
			// 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序)
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			// 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
			registryProcessors.addAll(currentRegistryProcessors);
			// 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法 这个方法主要用于注册所有的beandefibition
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			// 执行完毕后, 清空currentRegistryProcessors
			currentRegistryProcessors.clear();

			// 接下来，调用实现 Ordered 的 BeanDefinitionRegistryPostProcessors.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				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();

			// 最后，调用所有其他 BeanDefinitionRegistryPostProcessors 直到不再出现.
			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, beanFactory.getApplicationStartup());
				currentRegistryProcessors.clear();
			}

			// 现在，调用到目前为止处理的所有处理器的 postProcessBeanFactory 回调.
			// 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			// 最后, 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// 调用在上下文实例中注册的工厂处理器.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}
		// 这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕,

		// 不要在此处初始化 FactoryBeans：我们需要保留所有常规 bean 未初始化，以便让 bean 工厂后处理器应用于它们！

		// 找出所有实现BeanFactoryPostProcessor接口的类
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// 用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		// 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
		List<String> orderedPostProcessorNames = new ArrayList<>();
		// 用于存放普通BeanFactoryPostProcessor的beanName
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			// 跳过已经执行过的
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			// 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			// 添加实现了Ordered接口的BeanFactoryPostProcessor
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			// 剩下的普通BeanFactoryPostProcessor的beanName
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 首先，调用实现 PriorityOrdered 的 BeanFactoryPostProcessors.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 接下来，调用实现 Ordered 的 BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// 最后，调用所有其他 BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// 清除缓存的合并 bean 定义，
		// 因为后处理器可能已经修改了原始元数据，例如替换值中的占位符...
		beanFactory.clearMetadataCache();