Spring IOC(三): refresh 分析 invokeBeanFactoryPostProcessors 过程

接着上一篇文章走

postProcessBeanFactory

在 AbstractApplicationContext 中提供了给子类，在BeanFactory实例化前后进行的操作。

invokeBeanFactoryPostProcessors

初始并实例化所有 的BeanFactoryPostProcessor，这一段代码挺复杂，下面看看其代码：
从 invokeBeanFactoryPostProcessors 进入，直接去到 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());：

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

		if (beanFactory instanceof BeanDefinitionRegistry) {
		// 如果 factory类型为 BeanDefinitionRegistry
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				// BeanDefinitionRegistryPostProcessor 类型的 postProcessor
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
							// 首先先执行 BeanDefinitionRegistryPostProcessor 的接口方法。
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					// 而后加入到 registryProcessors 中。
					registryProcessors.add(registryProcessor);
				}
				else {
				// 普通的 postProcess
					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先执行 
			// 获取所有 BeanDefinitionRegistryPostProcessor 类型的bean。
			// 默认会有一个 org.springframework.context.annotation.internalConfigurationAnnotationProcessor
			// 即 ConfigurationClassPostProcessor
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 根据优先级排序
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					// 将其加入到 processedBeans
					processedBeans.add(ppName);
				}
			}
			// 根据beanFactory内部排序规则，给刚刚加入到 currentRegistryProcessors 进行排序。
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			// 将其全部加入到 BeanDefinitionRegistryPostProcessor 专属的集合 registryProcessors 中。
			registryProcessors.addAll(currentRegistryProcessors);
			// 先invoke 上面有实现 优先级中的 BeanDefinitionRegistryPostProcessor，即有优先级的先执行。
			// 默认为 有ConfigurationClassPostProcessor 
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			// 将 ConfigurationClassPostProcessor 清除
			currentRegistryProcessors.clear();

			// 将 BeanDefinitionRegistryPostProcessors 中，实现了 Ordered 的类进行调用，注意有优先级。
			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);
			// 将 刚找到的实现了 Ordered 的方法加入
			registryProcessors.addAll(currentRegistryProcessors);
			// 对其进行调用
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			// 清楚当前调用者信息
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			// 最后，将其他的 BeanDefinitionRegistryPostProcessor 类型给都调用了，知道没有。
			boolean reiterate = true;
			while (reiterate) {
			// 循环
				reiterate = false;
				// 每次都重新拿，所以是允许自定义的 对 BeanDefinitionRegistryPostProcessor 删减。
				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();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			// 执行beanpost的其他类型方法即 postProcessBeanFactory
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			// 执行普通的 postProcessors 的 postProcessBeanFactory 方法。
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

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

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		// 获取所有的BeanFactoryPostProcessor
		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
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 实现了 PriorityOrdered 的类
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				// 实现了 Ordered 的类
				orderedPostProcessorNames.add(ppName);
			}
			else {
				// 没有实现优先级的类。 
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 优先执行，实现了 PriorityOrdered 的 BeanFactoryPostProcessors
		// 排序
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 执行 
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 执行 实现了 Ordered 的 BeanFactoryPostProcessors
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// 执行其他类型的 BeanFactoryPostProcessors
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		 // 清除这个过程中部分临时数据
		beanFactory.clearMetadataCache();

Spring 通过各种不同的接入点，从而可以实现不同逻辑。同时也能够将bean容器提供给其他框架使用。
invokeBeanFactoryPostProcessors 方法 则是 调用 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor。
看看 这两个接口功能：

1. BeanDefinitionRegistryPostProcessor：是 BeanFactoryPostProcessor 接口标准SPI实现。能在 BeanFactoryPostProcessor 初始化之前 进行 beanDefinition 的注册。
2. BeanFactoryPostProcessor ：允许用户自定义操作去更改 ApplicationContext中的 BeanDefinition，但是不回影响到bean 实例。而如果 bean实例化的交互动作，则需要使用 BeanPostProcessor。

上面 invokeBeanFactoryPostProcessors 过程 可以有以下概括：

1. 依次 将 所有 实现 PriorityOrdered、Ordered 和 其他 的 BeanDefinitionRegistryPostProcessor 进行实例化。
   内置的为 ConfigurationClassPostProcessor。
   在 执行其他类型 BeanDefinitionRegistryPostProcessor 时候，Spring 采用的是每次都重新去 beanFactory 中获取，所以可以在自定义类型的 BeanDefinitionRegistryPostProcessor 增加 其他 BeanDefinitionRegistryPostProcessor。

			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();
			}

2. 依次执行 PriorityOrdered 、Ordered、其他 的 BeanFactoryPostProcessor 类型方法
   默认内置的为 EventListenerMethodProcessor。

Spring 中重要的 功能都是基于 PostProcessor 接入点实现，例如 @Configuration 等配置读取，@Autowired注入等。
接下来几篇文章，将分析 初始化中重要的 PostProcessor。

觉得博主写的有用，不妨关注博主公众号: 六点A君。
哈哈哈，一起研究Spring：