从源码解读Spring如何解决bean循环依赖
1 什么是bean的循环依赖
循环依赖的原文是circular reference，指多个对象相互引用，形成一个闭环。
以两个对象的循环依赖为例：
Spring中的循环依赖有 3 种情况：
- 构造器（constructor）的循环依赖；
- 字段（field）的循环依赖；
- 构造器与字段的循环依赖。
其中的第 2 、第 3 种情况Spring可以解决，但第 1 情况Spring无法解决。当出现构造器循环依赖的时候，会抛出异常：
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cat' defined in class path resource [constructor.xml]: Cannot resolve reference to bean 'dog' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'dog': Requested bean is currently in creation: Is there an unresolvable circular reference?
或
The dependencies of some of the beans in the application context form a cycle:
┌─────┐
| securityConfig defined in file [E:\IDEA\lab-back-end\target\classes\com\lpc\config\SecurityConfig.class]
↑ ↓
| userServiceImpl defined in file [E:\IDEA\lab-back-end\target\classes\com\lpc\service\impl\UserServiceImpl.class]
└─────┘
2 准备
准备两个POJO
public class Dog {
private String name;
private Cat friend;
public Dog() {
}
public Dog(String name, Cat friend) {
this.name = name;
this.friend = friend;
}
// 省略getter、setter
}
public class Cat {
private String name;
private Dog friend;
public Cat() {
}
public Cat(String name, Dog friend) {
this.name = name;
this.friend = friend;
}
// 省略getter、setter
}
Cat类里有个成员变量的类型是Dog类，同时Dog类里有个成员变量的类型是Cat类，满足了循环依赖的条件。
3 字段循环依赖的源码分析
3.1 field.xml
准备一个field.xml，这个xml配置了两个bean：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="dog" class="Dog">
<property name="name" value="dog"/>
<property name="friend" ref="cat"/>
</bean>
<bean id="cat" class="Cat">
<property name="name" value="cat"/>
<property name="friend" ref="dog"/>
</bean>
</beans>
xml里声明了两个bean，通过属性注入的方式将另一个bean引用到自己的成员变量中。在主类中加载xml：
ClassPathXmlApplicationContext ac
= new ClassPathXmlApplicationContext("field.xml");
3.2 方法的调用链
方法调用过程总结可以直接跳转到3.12。
3.3 AbstractBeanFactory#doGetBean()
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 省略部分代码
Object bean;
// 重要步骤
// 检查单例缓存中是否有手动注册单例bean
// 它其实是调了DefaultSingletonBeanRegistry#getSingleton(beanName, true)
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 省略部分代码
}
else {
// 省略部分代码
try {
// 省略部分代码
if (mbd.isSingleton()) {
// 重要步骤
sharedInstance = getSingleton(beanName, () -> {
try {
// 重要步骤
// singletonFactory.getObject()的具体实现。AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])
return createBean(beanName, mbd, args);
}
// 省略部分代码
});
// 省略部分代码
}
// 省略部分代码
}
// 省略部分代码
return (T) bean;
}
这里有两段代码是重点。
-
Object sharedInstance = getSingleton(beanName);这个方法调用的实际上是
getSingleton(beanName, true);。详见3.4。 -
sharedInstance = getSingleton(beanName, () -> { try { // 重要步骤 // singletonFactory.getObject()的具体实现。AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[]) return createBean(beanName, mbd, args); } // 省略部分代码 });详见3.5。
3.4 DefaultSingletonBeanRegistry#getSingleton(String, boolean)
DefaultSingletonBeanRegistry类的三个Map类型的成员变量，这三个成员变量也就是所谓的三级缓存。
// 一级缓存
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);
// 除了三级缓存以外，还有一个Set，beanName保存在这个Set里表示这个bean正在创建中
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 三级缓存其实就是三个Map，键是beanName
// 1 去一级缓存singletonObjects里获取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 如果 没有从一级缓存中获取到，且对象在正在创建中
// 判断对象正在创建中的方法是判断beanName是不是在singletonCurrentlyInCreation这个Set里
synchronized (this.singletonObjects) {
// 2 从二级缓存earlySingletonObjects中获取
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
// 如果 二级缓存中没有获取到，且allowEarlyReference为true
// 3.1 从三级缓存中获取，这时候获取到的是ObjectFactory，这是个工厂，并不是我们要实例
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 3.2 从对象工厂中获取实例
singletonObject = singletonFactory.getObject();
// 3.3 将获取到的实例保存到二级缓存（为什么不用保存到一级缓存）
this.earlySingletonObjects.put(beanName, singletonObject);
// 3.4 将工厂从三级缓存中移除
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
3.5 DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)
3.5其实是3.4的重载。
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
// 省略部分代码
synchronized (this.singletonObjects) {
// 去一级缓存中拿bean
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 省略部分代码
// 重要步骤
// 这个方法会将beanName添加到singletonsCurrentlyInCreation这个Set中
// 这步添加操作会在后面调用getSingletion(String, boolean)的时候起作用
beforeSingletonCreation(beanName);
// 省略部分代码
try {
// 重要步骤
// 在这一步创建了对象
// singletonFactory是作为参数传进来的匿名内部类
singletonObject = singletonFactory.getObject();
// 省略部分代码
}
// 省略部分代码
}
return singletonObject;
}
}
这里有两段代码是重点。
-
beforeSingletonCreation(beanName);这个方法会将beanName添加到
singletonsCurrentlyInCreation这个Set中。方法见3.6。singletonsCurrentlyInCreation的定义见3.4。 -
singletonObject = singletonFactory.getObject();singletonFactory是方法的参数，实际上是3.3第二段重要代码中用lambda创建的匿名内部类，实际上调用的是AbstractAutowireCapableBeanFactory类的doCreateBean(String, RootBeanDefinition, jObject[])
3.6 DefaultSingletonBeanRegistry#beforeSingletonCreation()java
protected void beforeSingletonCreation(String beanName) {
// inCreationCheckExclusions singletonsCurrentlyInCreation都是Set
// 这里在做判断的同时，调用了Set的add()方法
// 所以beanName被添加到了singletonsCurrentlyInCreation中
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
3.7 AbstractAutowireCapableBeanFactory#doCreateBean()
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
// 省略部分代码
if (instanceWrapper == null) {
// 重要步骤
// 在这里调用合适的构造方法生成实例，并将实例放在一个包装类中。这里就不详细展开了
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 从包装类中将实例取出来
final Object bean = instanceWrapper.getWrappedInstance();
// 省略部分代码
// 这个boolean值的结果取决于->单例、allowCircularReferences为true(默认就是true)、对象正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 省略部分代码
// 重要步骤
// 这个方法里会将bean添加到三级缓存中
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 重要步骤
// 给属性赋值
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
// 省略部分代码
}
这里有三段重要代码：
-
instanceWrapper = createBeanInstance(beanName, mbd, args);这个方法选择了合适的构造函数来构建实例。
-
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));在这个方法里将beanName和beanFactory放到了三级缓存中。详见3.8。
-
populateBean(beanName, mbd, instanceWrapper);
3.8 AbstractAutowireCapableBeanFactory#createBeanInstance()
3.9 DefaultSingletonBeanRegistry#addSingletonFactory()
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
// 如果 一级缓存中还没有这个beanName
// 在三级缓存中做一下保存
this.singletonFactories.put(beanName, singletonFactory);
// 在二级缓存中移除
this.earlySingletonObjects.remove(beanName);
// 在registeredSingletons里添加
this.registeredSingletons.add(beanName);
}
}
}
在这个方法里将beanName和beanFactory放到了三级缓存中。这时候，三级缓存里面已经有我要创建的dog对象（其实是有了创建这个对象的工厂）。
3.10 AbstractAutowireCapableBeanFactory#populateBean()
这个方法调用了AbstractAutowireCapableBeanFactory类applyPropertyValues()方法，applyPropertyValues()方法又调用了BeanDefinitionValueResolver类resolveReference()方法。最后又调用了doGetBean()，也就是3.3的方法。
doGetBean()在这里是为了给dog对象创建它的Cat类成员变量。
3.11 补充
在DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)方法中，还调用了addSingleton(beanName, singletonObject);，这个方法会将bean添加到第一级缓存中，并从第二、第三级缓存中移除。当然这一步跟解决循环依赖没有关系。
3.12 小总结
总结一下整个过程：
- 根据field.xml里声明的bean的顺序，先进行dog对象的创建；
- 去三级缓存中获取dog对象，这时候当然还没有，所以返回null；
- 将beanName（也就是"dog"）添加到了singletonsCurrentlyInCreation这个Set中；
- 通过一些列的判断条件，选择了合适的构造函数（这里是无参构造）来构建dog实例，此时的dog对象的成员变量都是null；
- 将beanName（也就是"dog"）放入第三级缓存中；
- 给dog对象的属性赋值。这时候发现dog对象的成员变量需要注入一个Cat类的对象。这时候就去创建cat对象，创建的过程相当于第2步到第6步；
- 同第2步，去三级缓存中获取cat对象，这时候当然也没有，所以返回null；
- 同第3步，将beanName（也就是"cat"）添加到了singletonsCurrentlyInCreation这个Set中；
- 同第4步，选择了合适的构造函数（这里是无参构造）来构建cat实例，此时的cat对象的成员变量都是null；
- 同第5步，将beanName（也就是"cat"）放入第三级缓存中；
- 同第6步，给cat对象的属性赋值。这时候发现cat对象的成员变量需要注入一个Dog类的对象。执行第2步，发现第三级缓存中，已经可以获取到dog对象了，就将dog对象取出来，并保存到第二级缓存中，同时从第三级缓存中移除dog对象。现在可以将dog对象赋值到cat对象的成员变量中了。cat对象创建完成；
- 回到第6步，将cat对象赋值到dog对象的成员变量中，dog对象也创建完成。
总的来说，Spring是依靠第三级缓存解决了循环依赖的问题，通过递归创建当前bean依赖的bean。
本文由博客群发一文多发等运营工具平台 OpenWrite 发布
