Spring源码系列文章
Spring源码解析(一):环境搭建
Spring源码解析(二):bean容器的创建、默认后置处理器、扫描包路径bean
Spring源码解析(三):bean容器的刷新
Spring源码解析(四):单例bean的创建流程
Spring源码解析(五):循环依赖
Spring源码解析(六):bean工厂后置处理器ConfigurationClassPostProcessor
Spring源码解析(七):bean后置处理器AutowiredAnnotationBeanPostProcessor
Spring源码解析(八):bean后置处理器CommonAnnotationBeanPostProcessor
Spring源码解析(九):AOP源码之@Aspect所有相关注解解析
Spring源码解析(十):spring整合mybatis源码
Spring源码解析(十一):spring事务配置类源码
Spring源码解析(十二):TransactionInterceptor事务拦截器
一、什么是循环依赖
- 简单点说,就是A依赖了B,B依赖的A
@Component
public class A {
@Autowired
private B b;
}
@Component
public class B {
@Autowired
private A a;
}
- 如果不处理,那么A创建时候需要属性填充B
- 此时B还没有创建,那么去创建B,又需要属性填充A
- 以此形成了死循环
二、什么情况下循环依赖可以被处理?
依赖情况 | 依赖注入方式 | 循环依赖是否被解决 |
---|---|---|
AB相互依赖(循环依赖) | 均采用setter方法注入 | 是 |
AB相互依赖(循环依赖) | 均采用构造器注入 | 否 |
AB相互依赖(循环依赖) | A中注入B的方式为setter方法,B中注入A的方式为构造器 | 是 |
AB相互依赖(循环依赖) | B中注入A的方式为setter方法,A中注入B的方式为构造器 | 否 |
三、简单的循环依赖(没有AOP)
Spring在创建Bean的过程中分为三步
- 实例化,简单理解就是new一个对象
- 属性注入,为实例化对象属性赋值
- 初始化,执行aware接口中的方法,初始化方法,完成
AOP
代理
以上面AB相互依赖为例
@Component
public class A {
@Autowired
private B b;
}
@Component
public class B {
@Autowired
private A a;
}
解读整个循环依赖处理的过程
- 整个流程应该是以A的创建为起点
- Spring在创建Bean的时候默认是按照自然排序来进行创建的,所以第一步Spring会去创建A
-
创建A的过程实际上就是调用
getBean
方法,这个方法有两层含义- 创建一个新的Bean
- 从缓存中获取到已经被创建的对象
1、getSingleton(beanName)缓存中获取对象
- 调用
getSingleton(a)
方法,这个方法又会调用getSingleton(beanName, true)
- true表示
允许提前曝光引用
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
-
getSingleton(beanName, true)这个方法实际上就是到缓存中尝试去获取Bean,整个缓存分为三级
singletonObjects
,一级缓存,存储的是所有创建好了的单例BeanearlySingletonObjects
,完成实例化,但是还未进行属性注入及初始化的对象singletonFactories
,提前暴露的一个单例工厂,二级缓存中存储的就是从这个工厂中获取到的对象
- if中代码不会执行,因为还没有到bean的创建中,这是创建前的操作
- 因为A是第一次被创建,所以不管哪个缓存中必然都是没有的
- 因此会进入getSingleton的另外一个重载方法
getSingleton(beanName, singletonFactory)
2、getSingleton(beanName, singletonFactory)从对象工厂中获取对象,添加到一级缓存
- 核心代码:通过
createBean
方法返回的Bean最终被放到了一级缓存
,也就是单例池中
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// ....
// 省略异常处理及日志
// ....
// 在单例对象创建前先做一个标记
// 将beanName放入到singletonsCurrentlyInCreation这个集合中
// 标志着这个单例Bean正在创建
// 如果同一个单例Bean多次被创建,这里会抛出异常
beforeSingletonCreation(beanName);
boolean newSingleton = false;
// ....
// 用于记录异常相关信息
// ....
try {
// 上游传入的lambda在这里会被执行,调用createBean方法创建一个Bean后返回
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
// ...
// 省略catch异常处理
// ...
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 创建完成后将对应的beanName从singletonsCurrentlyInCreation移除
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 添加到一级缓存singletonObjects中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
- 将从对象工厂中获取的对象放入一级缓存
- 将creatBean中放入二三缓存的东西删除到,因为以后不需要了
3、addSingletonFactory(beanName, singletonFactory) 创建对象工厂添加到三级缓存
- 这段代码是
creatBean
中的核心内容 - 也就是bean真正的创建
在完成Bean的实例化后,属性注入之前Spring将Bean包装成一个工厂对象添加进了三级缓存中
,对应源码如下:
- 这里只是添加了一个工厂,通过这个工厂(
ObjectFactory
)的getObject
方法可以得到一个bean对象 - 而这个对象实际上就是通过
getEarlyBeanReference
这个方法创建的
4、getEarlyBeanReference()对象工厂暴露的对象引用
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;
}
- 它实际上就是调用了后置处理器的
getEarlyBeanReference
- 而真正实现了这个方法的后置处理器只有一个,就是通过@EnableAspectJAutoProxy注解导入的AnnotationAwareAspectJAutoProxyCreator
- 也就是说如果在不考虑
AOP
的情况下,上面的代码等价于:
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
return exposedObject;
}
- 也就是说(不考虑AOP情况下)这个对象工厂啥都没干,直接将实例化阶段创建的对象返回了
总结
根据流程图串一下流程:
A依赖B,B依赖A,自然排序,所以先实例化A
- getBean(a),先从缓存中获取,没有,则需要去创建
- 实例化A,创建一个对象工厂,可以通过getObje返回刚实例化的A对象,将对象工厂放入三级缓存
- A属性填充,需要给A中的b属性赋值,则需要getBean(b),先从缓存中获取,没有,则需要去创建
- 实例化B,创建一个对象工厂,可以通过getObje返回刚实例化的A对象,将对象工厂放入三级缓存
-
B属性填充,需要给B中的a属性赋值,则需要getBean(a),从缓存中获取getSingleton(beanName, true)
- 此时a对象在创建中,所以会进入if方法
- 一级缓存中没有,则去二级缓存中找,也没有
- 最后从三级缓存获取对象工厂里的对象,放入二级缓存,并删除三级缓存的对象工厂
- B属性填充完毕后,初始化,然后B对象的创建流程完毕
- 接下来回到A的b属性填充,也就完成了
- A初始化,创建流程完毕,删除A的二级缓存,放入一级缓存
四、aop代理bean的循环依赖
- 在普通的循环依赖的情况下,三级缓存没有任何作用
- 三级缓存实际上跟Spring中的
AOP
相关,我们再来看一看getEarlyBeanReference
的代码:
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;
}
- 如果在
开启AOP
的情况下,那么就是调用到AnnotationAwareAspectJAutoProxyCreator
的getEarlyBeanReference
方法 - 对应的源码如下:
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
// 如果需要代理,返回一个代理对象,不需要代理,直接返回当前传入的这个bean对象
return wrapIfNecessary(bean, beanName, cacheKey);
}
- 回到上面的例子,如果我们对A进行了
AOP
代理的话 - 那么此时getEarlyBeanReference将返回一个代理后的对象
- 而不是实例化阶段创建的对象
- 这样就意味着B中注入的A将是一个
代理对象
而不是A的实例化阶段创建后的对象
代理bean的循环依赖过程
1、在给B注入的时候为什么要注入一个代理对象?
- 当我们对A进行了
AOP
代理时 - 说明我们希望从容器中获取到的就是A代理后的对象而不是A本身
- 因此把A当作依赖进行注入时也要注入它的代理对象
2、明明初始化的时候是A对象,那么Spring是在哪里将代理对象放入到容器中的呢?
- 首先A对象创建,然后将A
代理对象工厂
放入三级缓存 - 然后A执行到下图
populateBean()
属性填充时候去创建B - B属性填充的时候从三级缓存获取到
代理对象
,并放入二级缓存,并删除三级缓存 - B属性填充A的代理对象,然后初始化,B创建完毕,A属性赋值B也就完成了
- 接下来就是A的初始化,此时exposedObject还是A的
原始对象
- 最后从二级缓存中拿到代理对象,之后会添加到一级缓存,并删除二级缓存
3、初始化的时候是对A对象本身进行初始化,而容器中以及注入到B中的都是代理对象,这样不会有问题吗?
- 不会
- 因为不管是cglib代理还是jdk动态代理生成的代理类,内部都持有一个
目标类的引用
- 当调用代理对象的方法时,实际会去调用目标对象的方法,A完成初始化相当于代理对象自身也完成了初始化
4、三级缓存为什么要使用工厂而不是直接使用引用?换而言之,为什么需要这个三级缓存,直接通过二级缓存暴露一个引用不行吗?
- 这个工厂的目的在于
延迟
对实例化阶段生成的对象
的代理
- 只有真正发生循环依赖的时候,才去提前生成代理对象
- 否则只会创建一个工厂并将其放入到三级缓存中,但是不会去通过这个工厂去真正创建对象
我们思考一种简单的情况,就以单独创建A为例,假设AB之间现在没有依赖关系,但是A被代理了,这个时候当A完成实例化后还是会进入下面这段代码:
// A是单例的,mbd.isSingleton()条件满足
// allowCircularReferences:这个变量代表是否允许循环依赖,默认是开启的,条件也满足
// isSingletonCurrentlyInCreation:正在在创建A,也满足
// 所以earlySingletonExposure=true
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
// 还是会进入到这段代码中
if (earlySingletonExposure) {
// 还是会通过三级缓存提前暴露一个工厂对象
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
- 即使没有循环依赖,也会将其添加到三级缓存中,而且是不得不添加到三级缓存中
- 因为到目前为止Spring也不能确定这个Bean有没有跟别的Bean出现循环依赖
- 假设我们在这里直接使用二级缓存的话,那么意味着所有的Bean在这一步都要完成AOP代理
-
Spring结合AOP跟Bean的生命周期本身就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来完成的,在这个后置处理的postProcessAfterInitialization方法中对初始化后的Bean完成AOP代理
- 如果出现了
循环依赖
,那没有办法,只有给Bean先创建代理
- 但是没有出现循环依赖的情况下,设计之初就是让Bean在生命周期的
最后一步
完成代理而不是在实例化后就立马完成代理 - 如果
没有循环依赖
,只是三级缓存添加了一个代理A对象工厂(不会执行),A对象会在初始化最后一步生成代理对象,然后放入一级缓存,最后清空二三级缓存
- 如果出现了
五、总结
Spring是如何解决的循环依赖?文章来源:https://www.toymoban.com/news/detail-609464.html
- Spring通过三级缓存解决了循环依赖,其中一级缓存为单例池(
singletonObjects
),二级缓存为早期曝光对象(earlySingletonObjects
),三级缓存为早期曝光对象工厂(singletonFactories
) -
当A、B两个类发生循环引用时,在A完成实例化后,就使用实例化后的对象去创建一个对象工厂,并添加到三级缓存中
- 如果A被
AOP
代理,那么通过这个工厂获取到的就是A代理后的对象
- 如果A
没有被AOP
代理,那么这个工厂获取到的就是A实例化的对象
- 如果A被
-
当A进行属性注入时,会去创建B,同时B又依赖了A,所以创建B的同时又会去调用getBean(a)来获取需要的依赖,此时的getBean(a)会从缓存中获取
- 第一步,先获取到三级缓存中的
对象工厂
- 第二步,调用对象工工厂的
getObject方法
来获取到对应的对象,得到这个对象后将其注入到B中 - 紧接着B会走完它的生命周期流程,包括初始化、后置处理器等
- 第一步,先获取到三级缓存中的
- 当B创建完后,会将B再注入到A中,此时A再完成它的整个生命周期
- 至此,循环依赖结束!
为什么要使用三级缓存呢?二级缓存能解决循环依赖吗?文章来源地址https://www.toymoban.com/news/detail-609464.html
- 如果要使用二级缓存解决循环依赖,意味着所有Bean在
实例化后就要完成AOP代理
,这样违背了Spring设计的原则 - Spring在设计之初就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来在Bean生命周期的最后一步来完成AOP代理,而不是在实例化后就立马进行AOP代理
到了这里,关于Spring源码解析(五):循环依赖的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!