spring源码解析（八）：refresh()中invokeBeanFactoryPostProcessors()：实例化并调用bean工厂的后置处理器

最新推荐文章于 2024-07-17 10:49:07 发布

陈小亮L

最新推荐文章于 2024-07-17 10:49:07 发布

阅读量338

点赞数 1

分类专栏： spring源码之启动流程文章标签： spring

本文链接：https://blog.csdn.net/u011151359/article/details/99544633

版权

spring源码之启动流程专栏收录该内容

13 篇文章 4 订阅

订阅专栏

文章目录

spring refresh()中invokeBeanFactoryPostProcessors()：实例化并调用bean工厂的后置处理器
- 1. BeanFactoryPostProcessor：beanFactory的后置处理器
- 2.invokeBeanFactoryPostProcessors()

spring refresh()中invokeBeanFactoryPostProcessors()：实例化并调用bean工厂的后置处理器

查看invokeBeanFactoryPostProcessors方法：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 实例化并调用所有已注册的BeanFactoryPostProcessor
		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()));
		}
	}

该方法中实现了：

获取当前上下文beanFactoryPostProcessors变量的值。
实例化并调用bean工厂的后置处理器

invokeBeanFactoryPostProcessors()方法中会实例化并调用所有的bean工厂的后置处理器：BeanFactoryPostProcessor。

1. BeanFactoryPostProcessor：beanFactory的后置处理器

BeanFactoryPostProcessor：beanFactory的后置处理器；

在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；
所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建

@FunctionalInterface
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

2.invokeBeanFactoryPostProcessors()

PostProcessorRegistrationDelegate类是处理后置处理器的核心类，调用invokeBeanFactoryPostProcessors()方法。

invokeBeanFactoryPostProcessors()方法中两个接口：BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor。
其中BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor

实现流程：

从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。
1. 依次触发所有的postProcessBeanDefinitionRegistry()方法
2. 再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor；
从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法

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

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set<String> processedBeans = new HashSet<>();
        
        //beanFactory为DefaultListableBeanFactory,实现了BeanDefinitionRegistry接口
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			// 用于存放普通的BeanFactoryPostProcessor
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
			// 用于存放BeanDefinitionRegistryPostProcessor
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();

            //遍历bean工厂的后置处理器
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			    //1.如果bean工厂后置处理器是BeanDefinitionRegistryPostProcessor
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
				//执行方法：根据配置加载更多的bean定义	registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
				//2.普通的BeanDefinitionRegistryPostProcessor
					regularPostProcessors.add(postProcessor);
				}
			}

			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
            //在beanDefinitionNames中获取所有实现BeanDefinitionRegistryPostProcessor接口的name
            //本次例子中获取：org.springframework.context.annotation.internalConfigurationAnnotationProcessor
			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.add(ppName);
				}
			}
			//进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序)
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
			registryProcessors.addAll(currentRegistryProcessors);
			//遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//执行完毕后, 清空currentRegistryProcessors
			currentRegistryProcessors.clear();

            //同上文中一样：可能会新增了其他的BeanDefinitionRegistryPostProcessor, 因此需要重新查找
			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);
			currentRegistryProcessors.clear();

			//最后, 调用所有剩下的BeanDefinitionRegistryPostProcessors
			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();
			}

            //调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			//调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的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!
		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)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

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

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

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

		beanFactory.clearMetadataCache();
	}

总结：

执行BeanDefinitionRegistryPostProcessor
1. 83行：获取所有的BeanDefinitionRegistryPostProcessor；
2. 86行：看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
  postProcessor.postProcessBeanDefinitionRegistry(registry)
3. 99行：在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
  postProcessor.postProcessBeanDefinitionRegistry(registry)
4. 109行：最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
  postProcessor.postProcessBeanDefinitionRegistry(registry)
执行BeanFactoryPostProcessor的方法
1. 139行：获取所有的BeanFactoryPostProcessor
2. 147行：看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
  postProcessor.postProcessBeanFactory()
3. 167行：在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
  postProcessor.postProcessBeanFactory()
4. 175行：最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
  postProcessor.postProcessBeanFactory()