Spring的InstantiationAware后处理器

发表于 | 分类于 | 评论数： | 阅读次数：

InstantiationAwareBeanPostProcessor 是 BeanPostProcessor 的子接口，新增了一个实例化之前（BeforeInstantiation）的回调、一个实例化之后（AfterInstantiation）填充 property 之前的回调

接口定义

InstantiationAwareBeanPostProcessor 的类结构如下图所示：

image-20200407000326578

InstantiationAwareBeanPostProcessor 继承自 BeanPostProcessor 接口，它提供了 postProcessBeforeInstantiation 和 postProcessAfterInstantiation 两个方法，用于在 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. 通过 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 创建 bean 实例
  2. 若 bean 实例不为空，调用 BeanPostProcessor 的 postProcessAfterInitialization 方法做实例化后的处理

代码如下：

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%