Spring 调用 Bean 后置处理器

Spring 开始调用 bean 后置处理器，都是在 createBean 的时候，逐一开始调用，每次都处理不同的业务逻辑

第一次调用：判断是否需要 AOP

第一次调用 BeanPostProcessor 的继承了 InstantiationAwareBeanPostProcessor 接口的AnnotationAwareAspectJAutoProxyCreator 的 postProcessBeforeInstantiation 方法，是为了判断当前 bean 是否需要 AOP 代理，这里会提前找出那些不需要被代理的类，如：AppConfig，Aspect 等

@Nullable
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;
}
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // 调用后置处理器，如果开启了 @EnableAspectJAutoProxy
            // 就会调用 AnnotationAwareAspectJAutoProxyCreator 的 postProcessBeforeInstantiation
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

第二次调用：推断构造方法

为创建 bean 做准备，开始推断构造方法：处理实现了 SmartInstantiationAwareBeanPostProcessor 接口的后置处理器 AutowiredAnnotationBeanPostProcessor 的 determineCandidateConstructors 方法

• 提供了多个合格的构造方法，包括无参构造方法：
  • ctors == null，会调用无参构造方法，因为 spring 不知道应该利用那个构造方法装配

• 提供了一个构造方法，不是无参构造方法：
  • ctors != null，且 ctors = 1，会使用提供的构造方法，因为可以只能使用这个构造方法

• 提供了多个合格的构造方法，不含无参构造方法，且没有将其都标明 @Autowired(required=false)：
  • ctors != null，即 ctors > 1，会继续判断应该使用的方法，通常为参数值最长的方法

• 提供了多个合格的构造方法，至少有一个标明了 @Autowired(required=false) 并且没有 @Autowired(required=true)
  • ctors != null，即 ctors > 1，会继续推断使用哪一个构造方法，通常为第一个解析到的构造方法

• 提供了多个合格的构造方法，至少有一个标明了 @Autowired(required=true) 和 @Autowired(required=false)
  • 直接报异常：Invalid autowire-marked constructor

if (instanceWrapper == null) {
    // ★★★ 关键代码：开始推断构造方法，并创建 bean
    // 实例化对象，这里是【第二次】调用后置处理器：SmartInstantiationAwareBeanPostProcessor
    instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
    throws BeansException {
    if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                // 推断构造方法
                Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
                if (ctors != null) {
                    return ctors;
                }
            }
        }
    }
    return null;
}

第三次调用：应用合并之后的 BD

调用后置处理器：调用实现了 MergedBeanDefinitionPostProcessor 接口的 AutowiredAnnotationBeanPostProcessor 或 CommonAnnotationBeanPostProcessor 类的 postProcessMergedBeanDefinition 方法，这里仅仅将属性全部拿出来（包括父类），并进行缓存，并没有进行真正的注入，只是把需要注入的属性，放在一个 injectionMetadataCache Map 中保存起来其中 key = beanName, value = InjectionMetadata

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        // 判断是不是 MergedBeanDefinitionPostProcessor 类型
        if (bp instanceof MergedBeanDefinitionPostProcessor) {
            MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
            /*
                处理 @Resource
                CommonAnnotationBeanPostProcessor.postProcessMergedBeanDefinition
                1、调用父类的方法，查找所有生命周期回调方法：初始化和销毁
                2、findResourceMetadata() => 查找需要注入的元数据（这里只会处理 @Resource 注解的 Member（字段，构造方法，普通方法））
                3、checkConfigMembers() => 将 injectedElements 复制给 checkedElements（？为什么）
                处理 @Autowired
                AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition
                1、findAutowiringMetadata() => 查找需要注入的元数据（这里只会处理 @Autowired 和 @Value 注解的 Member（字段，构造方法，普通方法））
                2、checkConfigMembers() => 将 injectedElements 复制给 checkedElements（？为什么）
                 */
            bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
        }
    }
}

第四次调用：解决循环依赖，提前暴露一个工厂

这里并不是真正的第四次，因为是一个 lambda 表达式，会在处理属性注入的时候，才开始执行，我们只是简单的说是第四次

调用实现了 SmartInstantiationAwareBeanPostProcessor 接口的 AbstractAutoProxyCreator 类的 getEarlyBeanReference 方法，提前把这个 bean 的 ObjectFactory 放入 singletonFactories 中，并从三级缓存删除 bean

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

第五次调用：判断是否需要进行属性注入

特殊情况下如果不要属性注入，则在这一步进行，调用了实现 InstantiationAwareBeanPostProcessor 接口 postProcessAfterInstantiation 方法，返回 false 即表示不需要进行属性注入

populateBean(beanName, mbd, instanceWrapper);
// ★ 提供一个扩展点
// 如果程序员提供一个类，实现了 InstantiationAwareBeanPostProcessor，
// 并重写 postProcessAfterInstantiation 并返回 false，就不会完成属性注入
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // 调用 postProcessAfterInstantiation 方法，判断是否进行属性填充
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                // 只要有一个后置处理器返回 false，就不会进行属性填充
                continueWithPropertyPopulation = false;
                break;
            }
        }
    }
}

第六次调用：进行属性填充

查找 @Autowired 或 @Resource 注解的属性或方法，进行属性注入，此处调用了实现了 InstantiationAwareBeanPostProcessor 接口的 AutowiredAnnotationBeanPostProcessor 类 或 CommonAnnotationBeanPostProcessor 类的 postProcessProperties 方法完成属性注入，如果存在循环依赖，则在注入时，会调用二级缓存中的工厂方法

populateBean(beanName, mbd, instanceWrapper);
// 调用后置处理器，完成属性填充
for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
        // ★★★ 关键代码：进行属性填充
        // CommonAnnotationBeanPostProcessor 完成对 @Resource 属性的注入
        // AutowiredAnnotationBeanPostProcessor 完成对 @Autowired 属性的注入
        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;
    }
}

第七次调用：调用 bean 生命周期方法

调用所有实现了 BeanPostProcessor 接口的 postProcessBeforeInitialization 方法

• ApplicationContextAwareProcessor 类，完成了 aware 方法的调用
• InitDestroyBeanPostProcessor 接口的 CommonAnnotationBeanPostProcessor 类，完成 @PostConstructor 的调用

在第七次调用和第八次调用之间，完成了实现了 InitializingBean 接口的 afterPropertiesSet()，或指定了 init-method 方法的类

exposedObject = initializeBean(beanName, exposedObject, mbd);
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
    throws BeansException {
    Object result = existingBean;
    // ★★★ 执行直接实现了 BeanPostProcessor 的实现类的 postProcessBeforeInitialization 方法
    // ★ 这里处理生命周期方法的实现类是 CommonAnnotationBeanPostProcessor 类的 postProcessBeforeInitialization 方法
    // ★ 这里处理 Aware 实现类的是  ApplicationContextAwareProcessor 类的 postProcessBeforeInitialization 方法
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

第八次调用：执行对象的 AOP 代理

调用所有实现了 BeanPostProcessor 接口的 postProcessAfterInitialization 方法

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {
    Object result = existingBean;
    // 执行直接实现了 BeanPostProcessor 的类的 postProcessAfterInitialization 方法
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}