Spring —— BeanPostProcessor 后处理器梳理

前言

BeanPostProcessor，后处理器接口，暴露 钩子方法 用于自定义处理 bean，控制 bean 的 生命周期。本文梳理 BeanPostProcessor 的几个拓展接口以及部分实现类

版本

Spring 5.2.x

BeanPostProcessor

public interface BeanPostProcessor {

	@Nullable
	/**
	 * 在 bean 的初始化（初始化生命周期回调）之前执行，默认不做处理
	 */
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	@Nullable
	/**
	 * 在 bean 的初始化（初始化生命周期回调）之后执行，默认不做处理
	 */
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

在 bean 的属性注入完成、执行 bean 的 初始化回调 方法前后执行对应的 钩子方法，完成自定义操作，比如 代理

ApplicationContextAwareProcessor

class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;

	private final StringValueResolver embeddedValueResolver;

	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}

	@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	// Aware 相关回调
	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}
}

ApplicationContextAwareProcessor，Spring 内部使用，BeanPostProcessor 的实现类，重写了 postProcessBeforeInitialization 在 bean 实例 初始化之前，回调上述 Aware 接口

我们可以实现这类接口，拿到对应的实例，进行自定义操作。示例如下

@Service
public class HelloServiceImpl implements HelloService, EnvironmentAware {

	Environment environment;

	@Override
	public void setEnvironment(Environment environment) {
		// 本地持有
		this.environment = environment;

		// 操作
		/*((ConfigurableEnvironment) environment)
				.getPropertySources()
				.addLast(
						new MapPropertySource(
								"test",
								new HashMap<String, Object>() {
									{
										put("k", "v");
									}
								}
						));*/
	}
}

DestructionAwareBeanPostProcessor

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {

	// bean实例 销毁前回调，原型实例不生效
	void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;

	// 是否执行当前后置处理器
	default boolean requiresDestruction(Object bean) {
		return true;
	}

}

继承 BeanPostProcessor 拓展了 postProcessBeforeDestruction 回调方法，在 bean 销毁前回调

InitDestroyAnnotationBeanPostProcessor

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable

实现了 DestructionAwareBeanPostProcessor 和 MergedBeanDefinitionPostProcessor

• postProcessMergedBeanDefinition 方法用来填充 RootBeanDefinition 的 externallyManagedInitMethods 和 externallyManagedDestroyMethods 属性
• postProcessBeforeInitialization 方法在 bean 初始化前执行指定注解（@PostConstruct）标注的 初始化回调 方法
• postProcessBeforeDestruction 方法在 bean 销毁前执行指定注解标注（@PreDestroy）的 销毁回调 方法

InstantiationAwareBeanPostProcessor

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

	@Nullable
	/**
	 * 在创建 bean实例对象 前执行，如果返回一个不为 null 的对象（被代理）
	 * 则这之后的生命周期被“短路”，直接执行 BeanPostProcessor#postProcessAfterInitialization
	 */
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}

	/**
	 * bean实例对象创建完成后执行
	 * 如果返回 true，则进行属性填充
	 */
	default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		return true;
	}

	@Nullable
	// 属性注入
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
			throws BeansException {

		return null;
	}

	@Deprecated
	@Nullable
	default PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

		return pvs;
	}

}

继承了 BeanPostProcessor

• postProcessBeforeInstantiation 在实例化之前执行，如果返回一个非 null 的（代理）对象，则短路 生命周期 并执行 BeanPostProcessor#postProcessAfterInitialization，默认返回 null
• postProcessAfterInstantiation 在 单例 的实例对象创建完成之后执行，返回 true 则进行 属性填充，默认返回 true
• postProcessProperties 实现了 属性的注入，还有 @Autowired @Resource @Value 等注解的解析

SmartInstantiationAwareBeanPostProcessor

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

	@Nullable
	// 推断 给定bean 在 BeanPostProcessor#postProcessBeforeInstantiation 回调后的类型
	default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}

	@Nullable
	// 推断 给定bean 的构造方法
	default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
			throws BeansException {

		return null;
	}

	// 提前返回一个（代理）对象用于解决循环依赖
	default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

继承了 InstantiationAwareBeanPostProcessor

• predictBeanType 方法用于推断执行了 BeanPostProcessor#postProcessBeforeInstantiation 后的实例类型
• determineCandidateConstructors 方法用于推断给定 bean 的 构造方法，在创建 bean 的实例对象时调用
• getEarlyBeanReference 方法提前返回一个 （代理） 对象到 单例工厂缓存 中，用于解决 循环依赖

AbstractAutoProxyCreator

代理生成器，实现了 SmartInstantiationAwareBeanPostProcessor

• getEarlyBeanReference 方法提前返回一个 代理 对象，用于解决 循环依赖
• postProcessBeforeInstantiation 方法在必要条件下提前返回一个 代理对象 实例，短路 bean 的 生命周期
• postProcessAfterInitialization 执行 代理 操作

MergedBeanDefinitionPostProcessor

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {

	// 对实例对象创建完成后的 BeanDefinition 进行后处理
	void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);

	// 注册处理过的 BeanDefinition，并清除之前的缓存
	default void resetBeanDefinition(String beanName) {
	}

}

继承了 BeanPostProcessor，拓展了 postProcessMergedBeanDefinition 方法在实例对象创建完成后，后处理 BeanDefinition

AutowiredAnnotationBeanPostProcessor

public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
		implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware

继承了 InstantiationAwareBeanPostProcessorAdapter（一个空实现的 适配器 类），实现了 MergedBeanDefinitionPostProcessor

• postProcessMergedBeanDefinition，填充 RootBeanDefinition 的 externallyManagedConfigMembers 属性
• determineCandidateConstructors，在创建 bean 的实例对象时，推断对应的 构造方法，对于 构造方法 注入的 bean 提前创建 单例 并注入
• postProcessProperties，属性注入 的核心方法，支持 @Autowired @Value @Inject 注解的解析与处理

CommonAnnotationBeanPostProcessor

跟 AutowiredAnnotationBeanPostProcessor 一样，CommonAnnotationBeanPostProcessor 支持 @Resource 注解的 属性注入，同时上文介绍 InitDestroyAnnotationBeanPostProcessor 时提到，它指定了 初始化回调 的注解 @PostConstruct 和 销毁回调 的注解 @PreDestroy

总结

本文介绍了 BeanPostProcessor 及其部分子接口，对几个常用、核心的 后置处理器 的功能进行梳理，它们贯穿 bean 的整个 生命周期，起到不可忽视的作用