spring源码解析（一）bean的生命周期

首先来一张bean的生命周期图

该篇文章将以加载类为起点开始分析bean的生命周期。首先不能完全保证理解正确&＃xff0c;只是博主自己的思路&＃xff0c;有问题及时指出&＃xff0c;共同进步。

bean生命周期源码分析

加载类

源码将从AbstractAutowireCapableBeanFactory中的createBean方法开始分析&＃xff0c;也就是合并完beanDefinition&＃xff0c;开始加载类。

&＃64;Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, &＃64;Nullable Object[] args)throws BeanCreationException {...RootBeanDefinition mbdToUse &＃61; mbd;// 确保bean类在这一点上得到了实际的解析Class resolvedClass &＃61; resolveBeanClass(mbd, beanName);if (resolvedClass !&＃61; null && !mbd.hasBeanClass() && mbd.getBeanClassName() !&＃61; null) {mbdToUse &＃61; new RootBeanDefinition(mbd);mbdToUse.setBeanClass(resolvedClass);}// Prepare method overrides.try {mbdToUse.prepareMethodOverrides();}...try {// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.Object bean &＃61; resolveBeforeInstantiation(beanName, mbdToUse);if (bean !&＃61; null) {return bean;}}...try {Object beanInstance &＃61; doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace("Finished creating instance of bean &＃39;" &＃43; beanName &＃43; "&＃39;");}return beanInstance;}...}

从以上源码可以看到调用了第一个resolveBeanClass&＃xff0c;进入该方法查看。

//是否已经有了beanClass
if (mbd.hasBeanClass()) {return mbd.getBeanClass();
}
//安全管理器
if (System.getSecurityManager() !&＃61; null) {return AccessController.doPrivileged(new PrivilegedExceptionAction>() {&＃64;Overridepublic Class run() throws Exception {return doResolveBeanClass(mbd, typesToMatch);}}, getAccessControlContext());
}
else {//加载类&＃xff0c;这里面就是类加载器加载类的逻辑了return doResolveBeanClass(mbd, typesToMatch);
}

实例化前

分析完resolveBeanClass方法后回到createBean方法中来&＃xff0c;继续向下走&＃xff0c;看这一段代码。

try {//给BeanPostProcessors一个返回代理而不是目标bean实例的机会Object bean &＃61; resolveBeforeInstantiation(beanName, mbdToUse);//如果已经返回了对象&＃xff0c;则不再执行spring的实例化流程&＃xff0c;直接返回beanif (bean !&＃61; null) {return bean;}
}

resolveBeforeInstantiation方法中有这样两个方法&＃xff0c;bean通过InstantiationAwareBeanPostProcessor接口来实现两个影响实例化的方法&＃xff0c;允许第三方可以不按照Spring的正常流程来创建一个Bean&＃xff0c;利用InstantiationAwareBeanPostProcessor接口的方法来提前返回一个Bean对象&＃xff0c;直接结束Bean的生命周期&＃xff0c;从而达到干预bean实例化的过程。这就对应上一步 给BeanPostProcessors一个返回代理而不是目标bean实例的机会

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {Object bean &＃61; null;if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {// Make sure bean class is actually resolved at this point.if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {Class targetType &＃61; determineTargetType(beanName, mbd);if (targetType !&＃61; null) {bean &＃61; applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);if (bean !&＃61; null) {
//如果实例化前的时候返回了对象&＃xff0c;说明不再使用spring提供的实例化流程&＃xff0c;这时直接调用实例化后方法。bean &＃61; applyBeanPostProcessorsAfterInitialization(bean, beanName);}}}mbd.beforeInstantiationResolved &＃61; (bean !&＃61; null);}return bean;}

一个小demo

当对象是user时&＃xff0c;会被实例化前处理器处理&＃xff0c;生成一个order对象&＃xff0c;然后直接结束bean的生命周期。

&＃64;Component
public class MyInstantiation implements InstantiationAwareBeanPostProcessor {//允许第三方可以不按照Spring的正常流程来创建一个Bean&＃xff0c;
// 可以利用InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法来提前返回一个Bean对象&＃xff0c;
// 直接结束Bean的生命周期&＃64;Overridepublic Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {System.out.println("被干预的beanName:"&＃43;beanName);if (beanName.equals("user")){System.out.println("干预原本的bean的生命周期&＃xff0c;生成其他对象实例");return new Order();}return null;}}

推断构造方法和实例化

回到createBean方法中 继续向下走&＃xff0c;有这么一句代码。去做创建bean的操作

Object beanInstance &＃61; doCreateBean(beanName, mbdToUse, args);

进入doCreateBean方法查看。

BeanWrapper instanceWrapper &＃61; null;if (mbd.isSingleton()) {instanceWrapper &＃61; this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper &＃61;&＃61; null) {//在这里去执行了bean的实例化instanceWrapper &＃61; createBeanInstance(beanName, mbd, args);}//原始对象final Object bean &＃61; instanceWrapper.getWrappedInstance();//原始对象的class类型Class beanType &＃61; instanceWrapper.getWrappedClass();if (beanType !&＃61; NullBean.class) {mbd.resolvedTargetType &＃61; beanType;}

createBeanInstance方法中进行了构造方法的推断以及实例化&＃xff0c;作为单独篇章分析&＃xff1a;https://blog.csdn.net/qq_39404258/article/details/109769278

beanDefinition的后置处理

在doCreateBean方法中继续走&＃xff0c;到这里进行beanDefinition的后置处理

// 允许后处理程序修改合并的bean定义。
synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {//在这里可以添加修改beanDefinition的内容&＃xff0c;可以算作一个beanPostProcessor的扩展点applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}mbd.postProcessed &＃61; true;}
}

这里执行了applyMergedBeanDefinitionPostProcessors方法&＃xff0c;原理都是beanPostProcessor。自定义beanPostProcessor通过实现MergedBeanDefinitionPostProcessor接口内的相应方法即可。

在doCreateBean方法中继续走&＃xff0c;在这里进行了循环依赖的逻辑&＃xff0c;作为单独篇章分析&＃xff1a;https://blog.csdn.net/qq_39404258/article/details/108367587

// 如果当前创建的是单例bean&＃xff0c;并且允许循环依赖&＃xff0c;并且还在创建过程中&＃xff0c;那么则提早暴露boolean earlySingletonExposure &＃61; (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean &＃39;" &＃43; beanName &＃43;"&＃39; to allow for resolving potential circular references");}// 此时的bean还没有完成属性注入&＃xff0c;是一个非常简单的对象// 构造一个对象工厂添加到singletonFactories中&＃xff0c;getEarlyBeanReference暂时没断点到&＃xff0c;疑似lambda的问题addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); }// 该bean就是实例化对象
Object exposedObject &＃61; bean;

至此&＃xff0c;已经获取到了实例化对象&＃xff0c;接下来讲实例化对象进行属性填充。

实例化后

这时我们还在doCreateBean方法&＃xff0c;下面这个方法是属性填充方法

populateBean(beanName, mbd, instanceWrapper);

进入这个方法&＃xff0c;略过判空&＃xff0c;看这段循环。只有postProcessAfterInstantiation返回值是false才会进行属性填充&＃xff0c;否则直接结束属性填充。

// 在设置属性之前&＃xff0c;给任何instantiationwarebeanpostprocessors机会修改bean的状态。
// 我们可以自己写一个InstantiationAwareBeanPostProcessor&＃xff0c;然后重写postProcessAfterInstantiation&＃xff08;实例化后&＃xff09;方法来判断是否进行属性填充&＃xff0c;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp &＃61; (InstantiationAwareBeanPostProcessor) bp;// 如果该方法返回false,那么则不会进行属性填充了&＃xff0c;直接return了if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {return;}}}
}

属性填充

接着向下走是进行属性填充&＃xff08;依赖注入&＃xff09;&＃xff0c;作为一个单独的篇章进行分析。

&＃64;autowired源码注入分析https://blog.csdn.net/qq_39404258/article/details/109472260

aware回调

结束属性填充&＃xff0c;回到doCreateBean方法继续走。

//暴露这个对象
exposedObject &＃61; initializeBean(beanName, exposedObject, mbd);

然后进入initializeBean方法查看。

//安全处理器&＃xff0c;没有忽略
if (System.getSecurityManager() !&＃61; null) {AccessController.doPrivileged((PrivilegedAction) () -> {invokeAwareMethods(beanName, bean);return null;}, getAccessControlContext());
}
else {//调用aware回调invokeAwareMethods(beanName, bean);
}

初始化

在这个initializeBean方法内继续向下走&＃xff0c;执行初始化前、初始化、初始化后方法。

Object wrappedBean &＃61; bean;if (mbd &＃61;&＃61; null || !mbd.isSynthetic()) {
//执行postProcessBeforeInitialization() 方法&＃xff08;初始化前&＃xff09;wrappedBean &＃61; applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}try {//执行初始化方法init&＃xff0c;需实现InitializingBean接口invokeInitMethods(beanName, wrappedBean, mbd);}catch (Throwable ex) {throw new BeanCreationException((mbd !&＃61; null ? mbd.getResourceDescription() : null),beanName, "Invocation of init method failed", ex);}if (mbd &＃61;&＃61; null || !mbd.isSynthetic()) {
//执行postProcessAfterInitialization() 方法&＃xff08;初始化后&＃xff09;wrappedBean &＃61; applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}

销毁注册

再回到doCreateBean方法&＃xff0c;最后面有一个这样的方法registerDisposableBeanIfNecessary&＃xff0c;用于将实现了DisposableBean接口的bean注册进去用于close时的销毁。

registerDisposableBeanIfNecessary(beanName, bean, mbd);

以上为bean的部分生命周期&＃xff1a;:(加载类)-> 实例化->&＃xff08;填充属性&＃xff09;->&＃xff08;aware回调&＃xff09;->初始化。

总结一下在bean的生命周期里需要使用到的接口以及扩展的beanPostProcessor

1.加载类

2.实例化前  InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation

3.实例化 暂时没有分析

插入了一个beanDefinition后置处理器  MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition

4.实例化后 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation

5.填充属性 InstantiationAwareBeanPostProcessor.postProcessProperties

6.aware回调

7.初始化前 BeanPostProcessor.postProcessBeforeInitialization

8.初始化 InitializingBean.afterPropertiesSet,当然不止这一种可以初始化&＃xff0c;注解(&＃64;PostConstruct)和xml(init-method)方式都可以

9.初始化后 BeanPostProcessor.postProcessAfterInitialization

10.bean使用中

11.bean销毁 DisposableBean.destroy,当然不止这一种可以销毁&＃xff0c;注解(&＃64;PreDestroy)和xml(destroy-method)方式都可以