什么是Spring的循环依赖
Spring 的循环依赖问题指的是在 Spring 容器中,两个或多个 Bean 之间存在相互依赖关系,形成了一个循环依赖的情况。这种情况下,当 Spring 容器初始化时,无法正确地完成 Bean 的创建和依赖注入,导致程序出现错误或无法正常运行。
下面是通过GPT生成的一个例子来说明 Spring 的循环依赖问题:
假设有两个类 A 和 B,它们相互依赖:
public class A {
private B b;
public A(B b) {
this.b = b;
}
}
public class B {
private A a;
public B(A a) {
this.a = a;
}
}
在 Spring 容器中,我们定义了这两个 Bean:
<bean id="a" class="com.example.A">
<constructor-arg ref="b"/>
</bean>
<bean id="b" class="com.example.B">
<constructor-arg ref="a"/>
</bean>
当 Spring 容器初始化时,它会先创建 A 的实例,然后创建 B 的实例。但是在创建 A 的实例时,需要注入一个 B 的实例,而 B 的实例又需要注入一个 A 的实例,这样就形成了循环依赖。
由于循环依赖的存在,Spring 容器无法在初始化时正确地完成 Bean 的创建和依赖注入。它会尝试创建 A 的实例,但由于需要注入 B 的实例,而 B 的实例又需要注入 A 的实例,这样就陷入了一个无限循环的过程,最终导致栈溢出错误。
Spring解决循环依赖依靠的是Bean的“中间态”这个概念,而这个中间态指的是已经实例化,但还没初始化的状态。而构造器是完成实例化的,所以构造器的循环依赖无法解决
对Bean的创建最为核心三个方法解释如下:
createBeanInstance
:例化,其实也就是调用对象的构造方法实例化对象populateBean
:填充属性,这一步主要是对bean的依赖属性进行注入(@Autowired
)initializeBean
:回到一些形如initMethod
、InitializingBean
等方法
从对单例Bean的初始化可以看出,循环依赖主要发生在第二步(populateBean),也就是field属性注入的处理。
Spring 使用了三级缓存来解决循环依赖问题,这三级缓存分别是 singletonFactories、earlySingletonObjects 和 singletonObjects。
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
...
// 从上至下 分表代表这“三级缓存”
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 二级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三级缓存
...
/** Names of beans that are currently in creation. */
// 这个缓存也十分重要:它表示bean创建过程中都会在里面呆着~
// 它在Bean开始创建时放值,创建完成时会将其移出~
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/** Names of beans that have already been created at least once. */
// 当这个Bean被创建完成后,会标记为这个 注意:这里是set集合 不会重复
// 至少被创建了一次的 都会放进这里~~~~
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
- singletonFactories(三级缓存):在创建 Bean 的过程中,Spring 会将正在创建的 Bean 实例放入 singletonFactories 缓存中。这个缓存保存了正在创建但尚未完成的 Bean 实例。
- earlySingletonObjects(二级缓存):当 Bean 的创建过程中发现循环依赖时,Spring 会将已经创建完成的 Bean 实例放入 earlySingletonObjects 缓存中。这个缓存保存了已经创建完成但尚未完成依赖注入的 Bean 实例。
- singletonObjects(一级缓存):当 Bean 的依赖注入完成后,Spring 会将 Bean 实例放入 singletonObjects 缓存中。这个缓存保存了已经创建完成且依赖注入完成的 Bean 实例。(该级存放的是完整的bean实例,已经实例化和初始化好的实例)
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
...
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
...
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
protected boolean isActuallyInCreation(String beanName) {
return isSingletonCurrentlyInCreation(beanName);
}
...
}
上述的代码逻辑为:
先从一级缓存singletonObjects中去获取(如果获取到就直接retrun)。
如果获取不到或者对象正在创建中(isSingletonCurrentlyInCreation() ),那就再从二级缓存earlySingletonObjects中获取(如果获取到就直接retrun)。
如果还是获取不到,且允许singletonFactories(allowEarlyReference = true)通过getObject()获取,
就从三级缓存singletonFactory.getObject()获取(如果获取到了就从singletonFactories中移除,并且放进earlySingletonObjects。
其实也就是从三级缓存移动(是剪切、并不是复制)到了二级缓存)。
加入singletonFactories三级缓存的前提是执行了构造器,所以构造器的循环依赖没法解决!
getSingleton()从缓存里获取单例对象步骤分析可知,Spring解决循环依赖的诀窍:就在于singletonFactories这个三级缓存。
这个Cache里面都是ObjectFacotry,它是解决问题的关键。
从上述分析也能发现,解决Spring的循环依赖问题是通过三级缓存的方式来解决,并且只能是通过setter注入的方式来解决。
而通过 setter 的方式注入可以解决循环依赖的问题,原因如下:
- Spring 容器在创建 Bean 实例后,会先调用无参构造函数创建一个空对象,然后再通过 setter 方法进行属性注入。这样,在创建 Bean 实例时就不会陷入循环依赖的死循环。
- 通过 setter 方法注入属性时,可以先创建一个空对象,然后再通过 setter 方法将依赖的 Bean 注入进去。这样,在创建 Bean 实例时就可以解决循环依赖的问题。
然而,循环依赖问题是一种设计上的坏味道,应该尽量避免。如果在项目中出现了循环依赖问题,建议重新审视设计,尝试解耦相关的类,以避免出现循环依赖的情况。
为什么要用三级缓存而不是二级缓存
可以看到三级缓存各自保存的对象,这里重点关注二级缓存earlySingletonObjects和三级缓存singletonFactory,一级缓存可以进行忽略。前面我们讲过先实例化的bean会通过ObjectFactory半成品提前暴露在三级缓存中
所以如果没有AOP的话确实可以两级缓存就可以解决循环依赖的问题,如果加上AOP,两级缓存是无法解决的,不可能每次执行singleFactory.getObject()方法都给我产生一个新的代理对象,所以还要借助另外一个缓存来保存产生的代理对象