背景：
作为Spring系列的第二篇，本文结合容器的启动流程介绍单例Bean的生命周期，包括Bean对象的创建、属性设置、初始化、使用、销毁等阶段；在此过程中会介绍Spring用于操作Bean或者BeanDefinition的相关扩展接口。
文章重心在于介绍整个Bean生命周期，不拘泥于每个阶段的细节；因此本文中会常见到“主线逻辑”这个关键词，请读者不要对此反感。
容器的启动流程请参考：Spring系列-1 启动流程
1.Bean的生命周期
本文介绍单例Bean的生命周期，本文后续提到中Bean对象默认指代单例Bean。
1.1 流程图
每个Bean的生命周期都包括：实例化、属性设置、初始化、入单例池、销毁等阶段，整个流程可表示为：
上图中Bean的生命周期主流程可以分为4个部分：
[1] 实例化阶段
实例化阶段的核心目的是生成Bean对象，过程包括构造函数的推断与选择、通过反射调用目标构造函数实例化Bean对象。
Spring在框架中引入了InstantiationAwareBeanPostProcessor接口，提供了操作对象实例化的切入点；用户可以继承InstantiationAwareBeanPostProcessor接口自定义实例化对象过程。
[2] 属性设置阶段
属性设置阶段的核心任务是对已实例化的Bean对象根据配置进行属性设置。
InstantiationAwareBeanPostProcessor接口的postProcessProperties方法也提供给了用户干扰属性设置的能力。
MergedBeanDefinitionPostProcessor接口提供了操作Beandefinition信息的能力，也可以基于Beandefinition提取相关信息；如AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor在实现依赖注入时使用MergedBeanDefinitionPostProcessor进行依赖注入前的数据准备工作。
[3] 初始化阶段
初始化阶段是Spring框架为Bean对象自定义的一个阶段，目的在于当Bea对象完成实例化和属性注入后可以执行一些扩展方法。
该阶段按执行顺序包括：Aware接口的执行与相关Aware属性的设置、执行BeanPostProcessor的前置方法、执行初始化方法、执行BeanPostProcessor的后置方法。
其中，BeanPostProcessor的后置方法是依赖注入、AOP等实现原理(后续Spring系列文章中会反复见到BeanPostProcessor的后置方法)。
该阶段的核心逻辑是执行初始化方法，按照调用顺序包括：InitializingBean接口的afterPropertiesSet()方法 和
xml配置文件中通过Init-method属性指定的初始化方法。
[4] 销毁阶段
当容器被注销时，会销毁单例池中的Bean对象，此时进入Bean对象生命周期的销毁阶段，该阶段按照执行顺序包括：DisposableBean的destroy()方法和xml配置文件中通过destory-method属性指定的方法。
1.2 Bean生命周期方法
Bean生命周期方法是Bean对象级别的方法，即每种类型的Bean有自己的方法(仅作用于自己)，区别于Spring系统级别的方法(如BeanpostProcessor)作用于所有Bean对象。
1.2.1 Aware接口
Aware接口逻辑较为简单，用于向Bean对象种设置某种类型的属性，如下是BeanFactoryAware接口定义：
public interface BeanFactoryAware extends Aware {
void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
案例如下：
public class ComponentA implements BeanFactoryAware {
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
public Object getBean(String beanName) {
return beanFactory.getBean(beanName);
}
}
1.2.2 InitializingBean与DisposableBean
InitializingBean接口用于指定初始化逻辑，DisposableBean用于指定销毁逻辑：
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}
public interface DisposableBean {
void destroy() throws Exception;
}
1.2.3 SmartInitializingSingleton
public interface SmartInitializingSingleton {
void afterSingletonsInstantiated();
}
SmartInitializingSingleton在Spring容器完成所有非延迟单例Bean的注入到IOC容器后执行。
用户可通过SmartInitializingSingleton定义Bean注入到IOC后的自定义过程。
1.3 钩子函数
Spring提供这些钩子函数是为了提高Spring框架的扩展能力，基于Spring构造Bean对象的主流程衍生出新功能，
如依赖注入或者AOP代理等。
钩子函数作为Spring系统级别的方法作用于所有Bean对象。
1.3.1 MergedBeanDefinitionPostProcessor
public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
}
MergedBeanDefinitionPostProcessor接口除去因继承BeanPostProcessor引入的接口外，只有一个postProcessMergedBeanDefinition方法：通过beanDefinition，可修改beanDefinition以影响后续的属性设置；也可以从beanDefinition中提取信息做前置准备。
值得注意的是该接口不具备直接操作Bean对象的能力，原因如下：(1) 入参中没有携带Bean对象; (2) 此时Bean对象虽然已经被实例化，但是尚未加入三级缓存中, 即无法通过BeanFactory从IOC中获取该Bean对象。
1.3.2 BeanPostProcessor(BPP)
BeanPostProcessor中存在两个方法，postProcessBeforeInitialization和postProcessAfterInitialization：
public interface BeanPostProcessor {
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}
从名称可以看出postProcessBeforeInitialization在初始化方法之前执行，postProcessAfterInitialization在初始化方法之后执行。
postProcessBeforeInitialization和postProcessAfterInitialization均提高了直接修改Bean对象的能力：方法的入参上Bean对象和beanName, 返回值为修改后的Bean对象。需要注意：二者的执行时机都在Bean对象已完成实例化与属性赋值后。
其中，postProcessAfterInitialization方法的扩展能力被Spring使用得淋漓尽致；依赖注入、AOP等功能都是基于该方法的扩展能力而实现。
1.3.3 InstantiationAwareBeanPostProcessor(IABPP)
InstantiationAwareBeanPostProcessor接口的定义如下：
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
return null;
}
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;
}
}
// 除此之外，还有个postProcessPropertyValues方法，作用同postProcessProperties。
// 因被@Deprecated注解，本文选择进行忽略
InstantiationAwareBeanPostProcessor为扩展实例化过程提供了postProcessBeforeInstantiation和postProcessAfterInstantiation两个方法，为扩展属性设置过程提供了postProcessProperties方法。
基于InstantiationAwareBeanPostProcessor接口的设计目的，对该接口的说明需要结合Bean对象构建过程进行介绍，否则会失去其上下文意义(如同单词之于语句)。
postProcessBeforeInstantiation
postProcessBeforeInstantiation方法的入参为beanName和Bean对象的类型，用户可基于此构建Bean对象并返回，也可返回null(默认返回null)；当有对象返回时，将走扩展流程而不是按照Bean生命周期的主体流程来创建Bean对象。
创建Bean对象的createBean方法中主线逻辑如下：
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// ⚠️： 省略无关逻辑与try-catch等代码...
// ⚠️：步骤1:调用resolveBeforeInstantiation方法构造Bean对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 如果bean对象不为null，直接返回
if (bean != null) {
return bean;
}
// ⚠️：步骤2:调用doCreateBean方法构造Bean对象并返回
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
这里我们关注的重点在于resolveBeforeInstantiation(beanName, mbdToUse)方法，该方法的主线逻辑如下：
// ... 省略if分支，突出主线逻辑
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
return bean;
}
该方法逻辑较为简单，通过applyBeanPostProcessorsBeforeInstantiation调用IABPP的postProcessBeforeInstantiation方法构建Bean对象(遍历IOC中的IABPP对象，并调用其postProcessBeforeInstantiation方法；返回一个非空的对象，否则返回空)，如果为空则直接放回；否则通过applyBeanPostProcessorsAfterInitialization调用BPP的postProcessAfterInitialization方法操作Bean对象。
此时，Bean的构建过程如下所示：
因为，AOP和依赖注入的实现逻辑都在BPP的postProcessAfterInitialization方法，上述设计使得自定义的Bean对象仍然可以拥有Spring框架的依赖注入和AOP等功能。
postProcessAfterInstantiation和postProcessProperties
对postProcessAfterInstantiation和postProcessProperties二者的介绍放在一起是因为二者都发生在populate()方法中，可以从代码层面认为二者隶属于属性设置过程，populateBean方法的主线逻辑如下：
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// ⚠️：1.调用postProcessAfterInstantiation
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// ... pvs对象修改
// ⚠️：2.调用postProcessProperties
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
pvs = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
}
// ... check
// ⚠️：3.根据pvs的信息对Bean对象设置属性
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
populateBean方法的核心功能是进行属性设置，步骤可分为如下三步：
[1] 调用postProcessAfterInstantiation;
[2] 根据配置信息构造pvs对象，调用IABPP对象的postProcessProperties方法修改pvs对象;
[3] 根据pvs的信息对Bean对象设置属性.
其中：步骤[1]中遍历IOC容器中的IABPP对象，并调用其postProcessAfterInstantiation方法，当所有的调用结果都返回true时，继续执行步骤[2]和步骤[3]进行属性的设置；否则跳过步骤[2]和[3]，即不会执行属性设置流程.
2.案例介绍
略
3.原理
本章节基于Spring源码介绍Bean对象的构建过程。
3.1 触发时机
如Spring系列-1 启动流程文中介绍：在Spring容器启动之初先向IOC容器中注入Spring框架内置的组件对象、BeanFactory、BeanPostProcessor等Bean对象等, 之后初始化所有的非懒加载的单例Bean对象。过程中，当遇到依赖的Bean对象时，优先构造被依赖的Bean对象(无论是否时懒加载Bean).
AbstractBeanFactory.refresh()方法：
public void refresh() throws BeansException, IllegalStateException {
//...
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
//...
}
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//...
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons方法：
DefaultListableBeanFactory类提供的preInstantiateSingletons方法会加载所有的非lazy单例Bean，代码如下所示：
public void preInstantiateSingletons() throws BeansException {
//⚠️：说明：为突出Bean的主线逻辑，省去了FactoryBean逻辑以及一些包装的内容。
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
getBean(beanName);
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
smartSingleton.afterSingletonsInstantiated();
}
}
}
该方法对beanDefinitionNames进行了两次遍历：第一次遍历时对于非延迟的单例Bean调用getBean(beanName)方法构造Bean对象；第二次对于实现了SmartInitializingSingleton接口的Bean对象调用其afterSingletonsInstantiated方法，执行用户的自定义操作。
3.2 getBean和doGetBean
getBean方法：
该方法可以根据beanName获取Bean对象，如果对象不存在则创建该Bean对象。
public Object getBean(String name) throws BeansException {
// 以do开头的方法，一般是实际干活的
return doGetBean(name, null, null, false);
}
注意第二个参数是null，即调用doGetBean方法时，Class requiredType参数为null。
doGetBean方法：
doGetBean主线逻辑如下所示：
protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) {
String beanName = transformedBeanName(name);
Object beanInstance;
// ⚠️1：parentBeanFactory.getBean(nameToLookup)
// ⚠️2：checkMergedBeanDefinition(mbd, beanName, args);
// ⚠️3：优先构造被依赖的Bean对象
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
getBean(dep);
}
}
// ⚠️4: 构造Bean对象
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
return createBean(beanName, mbd, args);
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
//...
} else {
//...
}
// ⚠️5：类型校验&&适配
return adaptBeanInstance(name, beanInstance, requiredType);
}
doGetBean的主线逻辑可以分为如下五个步骤：
[1] 从父亲容器中获取Bean对象
如果当前容器中不存在beanName对应的Bean定义，Spring会尝试通过调用父容器的getBean方法获取Bean对象。
注意：父容器不能获取子容器中的Bean对象, 而子容器可以获取父容器中的Bean对象(因为子容器通过parentBeanFactory属性持有了父容器的引用)。
[2] 校验BeanDefinition
校验逻辑在checkMergedBeanDefinition方法中实现。
[3] 处理依赖关系
如果当前beanName对应的Bean对象存在依赖的Bean时，优先通过getBean方法处理被依赖的Bean对象。
如果存在相互依赖，则抛出BeanCreationException异常。
[4] 构造Bean对象
根据Bean的类型走不同的构造流程，当Bean为单例时，执行如下逻辑构造Bean对象：
sharedInstance = getSingleton(beanName, () -> createBean(beanName, mbd, args));
// getObjectForBeanInstance方法是为了适配FactoryBean类型的对象
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
上述lambda表达式用于传参给FactoryBean, 当执行该FactoryBean对象的getBean时会调用该表达式，因此
getSingleton方法的主线逻辑可以被整合为：
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
beforeSingletonCreation(beanName);
singletonObject = createBean(beanName, mbd, args);
afterSingletonCreation(beanName);
addSingleton(beanName, singletonObject);
}
return singletonObject;
}
首先尝试从单例池中根据beanName获取Bean对象，如果不为空——直接返回；否则调用createBean(beanName, mbd, args)构造Bean对象(前后环绕着beforeSingletonCreation和afterSingletonCreation方法)。addSingleton(beanName, singletonObject)用于将创建好的对象加入到单例池中并清理缓存。
[5] 类型校验和转换
adaptBeanInstance方法会根据requiredType确定是否执行类型校验和转换， 校验失败时抛出BeanNotOfRequiredTypeException异常：
<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return (T) convertedBean;
} catch (TypeMismatchException ex) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
当requiredType为null时，不经过任何处理直接返回。在上述getBean调用doGetBean方法时传递的requiredType为null, 因此在Spring容器初始化阶段构造的Bean对象不会经过类型校验和转换。
3.3 createBean和doCreateBean
createBean方法:
创建Bean对象的createBean方法中主线逻辑如下：
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// ⚠️： 省略无关逻辑与try-catch等代码...
// ⚠️：步骤1:调用resolveBeforeInstantiation方法构造Bean对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 如果bean对象不为null，直接返回
if (bean != null) {
return bean;
}
// ⚠️：步骤2:调用doCreateBean方法构造Bean对象并返回
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
主线逻辑分为两个步骤：(1) 调用resolveBeforeInstantiation方法构造Bean对象和 (2) 调用doCreateBean方法构造Bean对象。其中resolveBeforeInstantiation方法在请参考1.3.3 InstantiationAwareBeanPostProcessor节中的内容。
doCreateBean方法:
该方法的主线逻辑如下所示：
// 省略无关逻辑
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// ...
// ⚠️:1.实例化Bean对象
// Instantiate the bean.
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
Object bean = instanceWrapper.getWrappedInstance();
// ⚠️:2.将半成品对象加入三级缓存
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// ⚠️:3.Bean对象的属性设置
populateBean(beanName, mbd, instanceWrapper);
// ⚠️:4.Bean对象的初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);
// ⚠️:5.注册DisposableBean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
// ⚠️:6.返回对象
return exposedObject;
}
doCreateBean实际承担了构造Bean对象的任务，包括：
[1] 调用createBeanInstance实例化Bean对象；
[2] 将半成品的Bean对象加入三级缓存；
[3] 对Bean对象进行属性设置；
[4] 对Bean对象执行初始化；
[5] 注册实现了DisposableBean接口的Bean对象；
[6] 返回构建完成的Bean对象。
3.4 实例化
createBeanInstance方法：
通过createBeanInstance实例化Bean对象，代码如下所示：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 1.校验Bean对象的字节码对象：必须为public且存在public的构造方法
// 2.Supplier接口或者工厂方法不为空的，使用对应的构造流程构造Bean对象
// 3.使用构造函数构造Bean对象 {
//resolved表示构造函数是否已经解析完成；autowireNecessary表示是否需要自动装配
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
} else {
return instantiateBean(beanName, mbd);
}
}
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
return instantiateBean(beanName, mbd);
}
}
该方法主线逻辑有以下三个步骤：
[1] 校验Bean对象的字节码对象：必须为public且存在public的构造方法;
[2] Supplier接口或者工厂方法不为空的，使用对应的构造流程构造Bean对象;
[3] 使用Bean的构造函数构造Bean对象。
其中第三步为本文感兴趣的部分，整体上看：根据Bean的具体情况选择调用autowireConstructor或者instantiateBean方法进行实例化；并引入了两个标记变量：resolved表示构造函数是否已经完成过解析；autowireNecessary表示是否调autowireConstructor方法进行实例化。
另外，BeanDefinition对象的constructorArgumentsResolved属性用于标记是否已进行过构造函数推断(true表示使用autowireConstructor方法实例化Bean对象，false表示使用instantiateBean方法)，是一种优化：当同一个BeanDefinition被多次用于构造Bean对象时，不需要执行重复的推断步骤；该属性针对的是Prototype类型的Bean对象，对单例Bean没有优化的意义。
determineConstructorsFromBeanPostProcessors(beanClass, beanName)也是一个钩子函数，用于干预构造函数的选择：
如果用户自定义了SmartInstantiationAwareBeanPostProcessor实现类，且返回了通过determineConstructorsFromBeanPostProcessors(beanClass, beanName)为对应的bean确定了构造函数，则使用该构造函数实例化Bean对象。
因此，对于单例Bean对象上述逻辑可以简化为：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
}
}
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
} else {
return instantiateBean(beanName, mbd);
}
}
if (mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR
|| mbd.hasConstructorArgumentValues()
|| !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, null, args);
}
return instantiateBean(beanName, mbd);
}
其实，不看具体实现而仅从上述代码逻辑也可以推断出来：instantiateBean(beanName, mbd)表示调用无参构造函数实例化对象，而autowireConstructor(beanName, mbd, ctors, args)使用有参构造函数。
autowireConstructor方法封装了一个重要的概念，构造函数推断：
（1）当存在使用@Autowired注解的构造函数时，使用被@Autowired注解的构造函数实例化对象；
（2）当只有一个构造函数时，使用该构造函数；
（3）当存在多个构造函数且存在默认构造函数时，使用默认构造函数；
（4）当存在多个构造函数且不存在默认构造函数时，抛出异常。
3.5 populateBean
因介绍InstantiationAwareBeanPostProcessor而前置了该部分内容，请参考1.3.3 InstantiationAwareBeanPostProcessor节中的内容。
3.6 初始化
initializeBean方法：
该方法的源码如下：
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
// ⚠️：1.调用Aware接口
invokeAwareMethods(beanName, bean);
// ⚠️：2.调用BPP的postProcessBeforeInitialization方法
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
// ⚠️：3.执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
// ⚠️：4.调用BPP的postProcessAfterInitialization方法
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
// ⚠️：5.调用BPP的postProcessBeforeInitialization方法
return wrappedBean;
}
主线逻辑分为如下五个步骤：
(1) 调用Aware接口，进行Aware相关属性的设置;
(2) 调用BPP的postProcessBeforeInitialization方法；
(3) 执行初始化方法；
(4) 调用BPP的postProcessAfterInitialization方法；
(5) 调用BPP的postProcessBeforeInitialization方法。
invokeInitMethods方法：
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
// ⚠️：1.调用InitializingBean的afterPropertiesSet方法
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
((InitializingBean) bean).afterPropertiesSet();
}
// ⚠️：2.调用xml配置中通过init-method属性指定的初始化方法
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
其他步骤在上文中均已进行过介绍，此处不再赘述。
