java源码依赖分析_从源码解读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：

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">

xml里声明了两个bean，通过属性注入的方式将另一个bean引用到自己的成员变量中。在主类中加载xml：

ClassPathXmlApplicationContext ac

= new ClassPathXmlApplicationContext("field.xml");

3.2 方法的调用链

方法调用过程总结可以直接跳转到3.12。

3.3 AbstractBeanFactory#doGetBean()

protected T doGetBean(final String name, @Nullable final Class 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 singletonObjects = new ConcurrentHashMap<>(256);

// 二级缓存

private final Map earlySingletonObjects = new HashMap<>(16);

// 三级缓存

private final Map> singletonFactories = new HashMap<>(16);

// 除了三级缓存以外，还有一个Set，beanName保存在这个Set里表示这个bean正在创建中

private final Set 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 发布