Spring的InstantiationAware后处理器

InstantiationAwareBeanPostProcessorBeanPostProcessor 的子接口,新增了一个实例化之前(BeforeInstantiation)的回调、一个实例化之后(AfterInstantiation)填充 property 之前的回调

接口定义

InstantiationAwareBeanPostProcessor 的类结构如下图所示:

image-20200407000326578

InstantiationAwareBeanPostProcessor 继承自 BeanPostProcessor 接口,它提供了 postProcessBeforeInstantiationpostProcessAfterInstantiation 两个方法,用于在 bean 的实例化之前和实例化之后进行扩展。

1
2
3
4
5
6
7
8
9
10
11
// 实例化之前的回调
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
return null;
}

// 实例化之后的回调
default boolean postProcessAfterInstantiation(Object bean, String beanName)
throws BeansException {
return true;
}
1
2
3
4
5
6
7
8
9
10
// 属性填充
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)throws BeansException {
return null;
}

// 已废弃
@Deprecated
default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
return pvs;
}

方法介绍

postProcessBeforeInstantiation

postProcessBeforeInstantiation 是在 bean 实例化之前的回调。所谓实例化,就是通过构造方法、factoryBean 等创建 bean 的实例,但不包括填充 bean 的属性值。

image-20200402015737100

上图展示了 bean 的创建过程,其中第一步是创建 bean 实例,Spring 在这之前提供了一个扩展点,允许通过 BeanPostProcess 创建 bean 的代理出来,这样就不走后面的创建 bean 流程。相关代码在 AbstractAutowireCapableBeanFactory 的 createBean 方法中:

1
2
3
4
5
// 给 BeanPostProcessors 一个机会,可以创建 bean 的代理出来,这样就不走后面的创建 bean 逻辑
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}

resolveBeforeInstantiation 的主要逻辑是:

  1. 通过 InstantiationAwareBeanPostProcessorpostProcessBeforeInstantiation 创建 bean 实例
  2. 若 bean 实例不为空,调用 BeanPostProcessorpostProcessAfterInitialization 方法做实例化后的处理

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 实例化之前的回调,如果返回的不为空,说明已经自定义了实例化及初始化,相当于短路了
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 初始化之后的回调
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}

postProcessAfterInstantiation

postProcessAfterInstantiation 是在 bean 实例化之后的回调,它是 populateBean 阶段的第一步,在属性填充之前。若 postProcessAfterInstantiation 返回了 false,则不会再走后续的属性填充逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
boolean continueWithPropertyPopulation = true;

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
// 不需要继续填充属性
continueWithPropertyPopulation = false;
break;
}
}
}
}

// 不需要属性填充,直接返回
if (!continueWithPropertyPopulation) {
return;
}

postProcessProperties

InstantiationAwareBeanPostProcessor 还提供了一个 postProcessProperties 方法,在 populateBean 阶段 autowireByName 和 autowireByType 处理之后会回调该方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// @Autowire 依赖注入在此实现
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
0%