spring源码：BeanFactoryPostProcessor原理

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

Bronze5

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

阅读量337

点赞数

分类专栏： spring源码文章标签： BeanFactory后处理器 postprocessor spring源码

本文链接：https://blog.csdn.net/Bronze5/article/details/105915020

版权

spring源码专栏收录该内容

30 篇文章 11 订阅

订阅专栏

一、介绍

Spring IoC容器允许BeanFactoryPostProcessor(即BeanFactory后处理器)读取配置元数据，并能在容器实例化除BeanFactoryPostProcessor实例之外的任何bean之前更改它。
Spring我们可以配置多个BeanFactoryPostProcessor实例，并且可以通过实现Order或PriorityOrdered接口设置order属性，来控制这些BeanFactoryPostProcessor实例的运行顺序。有关更多细节，请参见官方文档。
从上面的描述我们可以得到两个信息：1.BeanFactory后处理器在初始化任何非BeanFactoryPostProcessor的bean实例之前调用；2.调用顺序与Order或PriorityOrdered接口有关。

二、使用示例

目的：改变一个bean的属性值

注册一个Department类的Bean

定义一个Department类

@Data
public class Department {
    private Integer id;
    private String name;
}

在applicationContext.xml中配置bean

    <bean id="departmentBean" class="com.kaka.spring.pojo.Department">
        <property name="id" value="1"/>
        <property name="name" value="销售部"/>
    </bean>

此时部门名称为：销售部

自定义BeanFactory后处理器

新建MyBeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 1. 从bean工厂中获取departmentBean的bean定义信息
        BeanDefinition departmentBean = beanFactory.getBeanDefinition("departmentBean");
		// 2. 获取BeanDefinition中的属性信息
        MutablePropertyValues propertyValues = departmentBean.getPropertyValues();
        List<PropertyValue> propertyValueList = propertyValues.getPropertyValueList();
        for (PropertyValue propertyValue : propertyValueList) {
            // 3. 给departmentBean的name属性，设置为“技术部”
            if ("name".equals(propertyValue.getName())) {
                propertyValue.setConvertedValue("技术部");
            }
        }
    }
}

在applicationContext.xml文件中配置BeanFactory后处理器

<bean id="myBeanFactoryPostProcessor" class="com.kaka.spring.beans.factory.config.MyBeanFactoryPostProcessor"/>

测试代码

    @Test
    public void beanFactoryPostProcessorTest(){
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        Department departmentBean = classPathXmlApplicationContext.getBean("departmentBean", Department.class);
        System.out.println(departmentBean);
    }

执行结果
在这里插入图片描述
可以看到此时department的name已变为“技术部”

三、源码剖析

刷新application上下文

	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 1. 准备刷新的上下文环境
			prepareRefresh();

			// 2. 初始化BeanFactory，并进行XML文件的加载
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 3. 对BeanFactory进行各种功能填充
			prepareBeanFactory(beanFactory);

			try {
				// 4. 子类覆盖犯法做额外的处理
				postProcessBeanFactory(beanFactory);

				// 5. 调用BeanFactory后处理器
				invokeBeanFactoryPostProcessors(beanFactory);

				// 6. 注册bean后处理器，在调用getBean的时候回调这些bean后处理器的方法
				registerBeanPostProcessors(beanFactory);

				// 7. 为上下文初始化Message源
				initMessageSource();

				// 8. 初始化应用消息广播器，并放入ApplicationEventMulticaster中
				initApplicationEventMulticaster();

				// 9. 留给子类初始化其他bean
				onRefresh();

				// 10. 注册监听器
				registerListeners();

				// 11. 初始化剩下的单例Bean（非惰性的）
				finishBeanFactoryInitialization(beanFactory);

				// 12. 最后一步，发布通知事件
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// 销毁已经创建的单例，以避免挂起资源。
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

该代码来自AbstractApplicationContext类的refresh方法，是ApplicationContext初始化的入口。整个Spring框架加载的过程就是这个方法中，可以好好看一下。跟本文相关的是，第5步调用BeanFactory后处理器，在第11步初始化所有单例bean之前。

调用BeanFactory后处理器

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		
		// 调用Bean工厂中的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()));
		}
	}

注意下PostProcessorRegistrationDelegate这个类，调用BeanFactory后处理器的方法和注册Bean后处理的过程都在这个类中。

调用BeanFactory后处理器的方法，在PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors方法中，点进去看下：

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

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

		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();

			// 1. 调用传进来的beanFactoryPostProcessors，这个我们不用关心，一般是spring内部的BeanFactory后处理器
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// 2. 处理BeanDefinitionRegistryPostProcessor类型的BeanFactory后处理器
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// 2.1 调用实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
			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);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			// 调用BeanDefinitionRegistry后处理器的postProcessBeanDefinitionRegistry()方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// 2.2 调用实现Ordered接口的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);
			// 调用BeanDefinitionRegistry后处理器的postProcessBeanDefinitionRegistry()方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// 2.3 最后，调用其他的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);
				// 调用BeanDefinitionRegistry后处理器的postProcessBeanDefinitionRegistry()方法
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// 再调用BeanDefinitionRegistry后处理器的postProcessBeanFactory()方法
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

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

		// 3. 处理普通的BeanFactoryPostProcessor
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
		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);
			}
		}

		// 3.1 调用实现PriorityOrdered接口的BeanFactoryPostProcessors
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

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

		// 3.3 最后，调用所有其他的BeanFactoryPostProcessors
		// 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();
	}

以上代码的逻辑分为三部分：

调用传入的BeanFactoryPostProcessor；
按顺序调用BeanDefinitionRegistryPostProcessor类型的BeanFactory后处理器；
按顺序调用普通的BeanFactory后处理器。
这里说的按顺序规则为：PriorityOrdered接口 > Ordered接口 > 其他；其中order的值越小，优先级越高

BeanDefinitionRegistryPostProcessor类型的BeanFactory后处理器，有两个接口方法：postProcessBeanDefinitionRegistry和postProcessBeanFactory
普通的BeanFactory后处理器，只有postProcessBeanFactory一个方法

四、小结

如果需要向容器中注册bean就使用BeanDefinitionRegistryPostProcessor类型的BeanFactory后处理器，把逻辑写在postProcessBeanDefinitionRegistry方法中；
如果仅仅使用或修改bean工厂的元信息(BeanDefinition、环境信息、属性信息等)，使用普通的BeanFactory后处理器就够了，把逻辑写在postProcessBeanFactory方法中。

ps：spring中的PropertySourcesPlaceholderConfigurer用来解析xml文件中占位符，这个类就是一个普通的BeanFactory后处理器，有兴趣的可以看下。