Spring之循环依赖与解决方案

xiaoxiao2024-11-11 65

GitHub：https://github.com/JDawnF/learning_note

1. 什么是循环依赖

2. 解决循环依赖

2.1 getSingleton

2.2 addSingletonFactory(二级缓存出处)

2.3 addSingleton(一级缓存出处)

3. 小结

1. 什么是循环依赖

循环依赖，其实就是循环引用，就是两个或者两个以上的 bean 互相引用对方，最终形成一个闭环，如 A 依赖 B，B 依赖 C，C 依赖 A。如下图所示：

循环依赖，其实就是一个死循环的过程，在初始化 A 的时候发现引用了 B，这时就会去初始化 B，然后又发现 B 引用 C，跑去初始化 C，初始化 C 的时候发现引用了 A，则又会去初始化 A，依次循环永不退出，除非有终结条件。

Spring 循环依赖的场景有两种：

构造器的循环依赖。

@Service public class A { public A(B b) { } } @Service public class B { public B(C c) { } } @Service public class C { public C(A a) { } }

结果：项目启动失败，发现了一个cycle

field 属性的循环依赖。

scope为单例的时候：

@Service public class A1 { @Autowired private B1 b1; } @Service public class B1 { @Autowired public C1 c1; } @Service public class C1 { @Autowired public A1 a1; }

结果：项目启动成功

scope为prototype的时候

@Service @Scope("prototype") public class A1 { @Autowired private B1 b1; } @Service @Scope("prototype") public class B1 { @Autowired public C1 c1; } @Service @Scope("prototype") public class C1 { @Autowired public A1 a1; }

结果：项目启动失败，发现了一个cycle

对于构造器的循环依赖，Spring 是无法解决的，只能抛出 BeanCurrentlyInCreationException 异常表示循环依赖，所以下面我们分析的都是基于 field 属性的循环依赖。

Spring 只解决 scope 为 singleton 的循环依赖。对于scope 为 prototype 的 bean ，Spring 无法解决，直接抛出 BeanCurrentlyInCreationException 异常。

为什么 Spring 不处理 prototype bean 呢？其实如果理解 Spring 是如何解决 singleton bean 的循环依赖就明白了。这里先卖一个关子，我们先来关注 Spring 是如何解决 singleton bean 的循环依赖的。

2. 解决循环依赖

2.1 getSingleton

我们先从加载 bean 最初始的方法 AbstractBeanFactory 的 doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) 方法开始。

在 doGetBean(...) 方法中，首先会根据 beanName 从单例 bean 缓存中获取，如果不为空则直接返回。代码如下：

// AbstractBeanFactory.java Object sharedInstance = getSingleton(beanName);

调用 getSingleton(String beanName, boolean allowEarlyReference) 方法，从单例缓存中获取。代码如下：

// DefaultSingletonBeanRegistry.java @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 从单例缓冲中加载 bean Object singletonObject = this.singletonObjects.get(beanName); // 缓存中的 bean 为空，且当前 bean 正在创建 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { // 加锁 synchronized (this.singletonObjects) { // 从 earlySingletonObjects 获取 singletonObject = this.earlySingletonObjects.get(beanName); // earlySingletonObjects 中没有，且允许提前创建 if (singletonObject == null && allowEarlyReference) { // 从 singletonFactories 中获取对应的 ObjectFactory ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { // 获得 bean singletonObject = singletonFactory.getObject(); // 添加 bean 到 earlySingletonObjects 中 this.earlySingletonObjects.put(beanName, singletonObject); // 从 singletonFactories 中移除对应的 ObjectFactory this.singletonFactories.remove(beanName); } } } } return singletonObject; }

这个方法主要是从三个缓存中获取，分别是：singletonObjects、earlySingletonObjects、singletonFactories 。三者定义如下：

// DefaultSingletonBeanRegistry.java /** * Cache of singleton objects: bean name to bean instance. * 一级缓存，保存所有的singletonBean的实例 * 存放的是单例 bean 的映射。 * 对应关系为 bean name --> bean instance */ private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); /** * Cache of singleton factories: bean name to ObjectFactory. * 三级缓存，singletonBean的生产工厂 * 存放的是【早期】的单例 bean 的映射。 * 对应关系也是 bean name --> bean instance。 * * 它与 {@link singletonObjects} 的区别区别在，于 earlySingletonObjects 中存放的 bean 不一定是完整的。 * * 从 {@link getSingleton(String)} 方法中，中我们可以了解，bean 在创建过程中就已经加入到 earlySingletonObjects 中了， * 所以当在 bean 的创建过程中就可以通过 getBean() 方法获取。 * 这个 Map 也是解决【循环依赖】的关键所在。 **/ private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); /** * Cache of early singleton objects: bean name to bean instance. * 二级缓存，保存所有早期创建的Bean对象，这个Bean还没有完成依赖注入 * 存放的是 ObjectFactory 的映射，可以理解为创建单例 bean 的 factory 。 * 对应关系是 bean name --> ObjectFactory */ private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

singletonObjects ：单例对象的 Cache 。

singletonFactories ：单例对象工厂的 Cache 。

earlySingletonObjects ：提前曝光的单例对象的 Cache 。

它们三，就是 Spring 解决 singleton bean 的关键因素所在，我称他们为三级缓存：

第一级为 singletonObjects

第二级为 earlySingletonObjects

第三级为 singletonFactories

这里，我们已经通过 getSingleton(String beanName, boolean allowEarlyReference) 方法，看到他们是如何配合的。详细分析该方法之前，提下其中的 isSingletonCurrentlyInCreation(String beanName) 方法和 allowEarlyReference变量：

isSingletonCurrentlyInCreation(String beanName) 方法：判断当前 singleton bean 是否处于创建中。bean 处于创建中，也就是说 bean 在初始化但是没有完成初始化，有一个这样的过程其实和 Spring 解决 bean 循环依赖的理念相辅相成。因为 Spring 解决 singleton bean 的核心就在于提前曝光 bean 。

allowEarlyReference 变量：从字面意思上面理解就是允许提前拿到引用。其实真正的意思是，是否允许从 singletonFactories 缓存中通过 getObject() 方法，拿到对象。因为 singletonFactories 才是 Spring 解决 singleton bean 的诀窍所在。

getSingleton(String beanName, boolean allowEarlyReference) 方法，整个过程如下：

首先，从一级缓存 singletonObjects 获取。

如果，没有且当前指定的 beanName 正在创建，就再从二级缓存 earlySingletonObjects 中获取。

如果，还是没有获取到且允许 singletonFactories 通过 getObject() 获取，则从三级缓存 singletonFactories 获取。如果获取到，则通过其 getObject() 方法，获取对象，并将其加入到二级缓存 earlySingletonObjects 中，并从三级缓存 singletonFactories 删除。代码如下：

// DefaultSingletonBeanRegistry.java singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName);

这样，就从三级缓存升级到二级缓存了。

所以，二级缓存存在的意义，就是缓存三级缓存中的 ObjectFactory 的 getObject() 方法的执行结果，提早曝光的单例 Bean 对象。

2.2 addSingletonFactory(二级缓存出处)

上面是从缓存中获取，但是缓存中的数据从哪里添加进来的呢？一直往下跟会发现在 AbstractAutowireCapableBeanFactory 的 doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) 方法中，有这么一段代码：

// AbstractAutowireCapableBeanFactory.java boolean earlySingletonExposure = (mbd.isSingleton() // 单例模式 && this.allowCircularReferences // 运行循环依赖 && isSingletonCurrentlyInCreation(beanName)); // 当前单例 bean 是否正在被创建 if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // 提前将创建的 bean 实例加入到 singletonFactories 中 // 这里是为了后期避免循环依赖 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); }

当一个 Bean 满足三个条件时，则调用addSingletonFactory(...)方法，将它添加到缓存中。三个条件如下：

单例

运行提前暴露 bean

当前 bean 正在创建中

addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) 方法，代码如下：

// DefaultSingletonBeanRegistry.java protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { this.singletonFactories.put(beanName, singletonFactory); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } } }

从这段代码我们可以看出，singletonFactories 这个三级缓存才是解决 Spring Bean 循环依赖的诀窍所在。同时这段代码发生在 createBeanInstance(...) 方法之后，也就是说这个 bean 其实已经被创建出来了，但是它还不是很完美（没有进行属性填充和初始化），但是对于其他依赖它的对象而言已经足够了（可以根据对象引用定位到堆中对象），能够被认出来了。所以 Spring 在这个时候，选择将该对象提前曝光出来让大家认识认识。

2.3 addSingleton(一级缓存出处)

介绍到这里我们发现三级缓存 singletonFactories 和二级缓存 earlySingletonObjects 中的值都有出处了，那一级缓存在哪里设置的呢？在类 DefaultSingletonBeanRegistry 中，可以发现这个 addSingleton(String beanName, Object singletonObject) 方法，代码如下：

// DefaultSingletonBeanRegistry.java protected void addSingleton(String beanName, Object singletonObject) { synchronized (this.singletonObjects) { this.singletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } }

添加至一级缓存，同时从二级、三级缓存中删除。

这个方法在 doGetBean(...) 方法中，处理不同 scope 时，如果是 singleton，则调用 getSingleton(...) 方法，如下图所示：

getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法，代码如下：

// AbstractBeanFactory.java 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) { //.... try { singletonObject = singletonFactory.getObject(); newSingleton = true; } //..... if (newSingleton) { addSingleton(beanName, singletonObject); } } return singletonObject; } }

注意，此处的 getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法，在 AbstractBeanFactory 类中实现，和上面的2.1 getSingleton不同。

3. 小结

Spring 解决循环依赖的方案主要如下：

Spring 在创建 bean 的时候并不是等它完全完成，而是在创建过程中将创建中的 bean 的 ObjectFactory 提前曝光（即加入到 singletonFactories 缓存中）。

这样，一旦下一个 bean 创建的时候需要依赖 bean ，则直接使用 ObjectFactory 的 getObject() 方法来获取了，也就是上面的2.1 getSingleton 小结中的方法中的代码片段了。

到这里，关于 Spring 解决 bean 循环依赖就已经分析完毕了。最后来描述下就上面那个循环依赖 Spring 解决的过程：

首先 A 完成初始化第一步并将自己提前曝光出来（通过 ObjectFactory 将自己提前曝光），在初始化的时候，发现自己依赖对象 B，此时就会去尝试 get(B)，这个时候发现 B 还没有被创建出来

然后 B 就走创建流程，在 B 初始化的时候，同样发现自己依赖 C，C 也没有被创建出来

这个时候 C 又开始初始化进程，但是在初始化的过程中发现自己依赖 A，于是尝试 get(A)，这个时候由于 A 已经添加至缓存中（一般都是添加至三级缓存 singletonFactories ），通过 ObjectFactory 提前曝光，所以可以通过 ObjectFactory的getObject() 方法来拿到 A 对象，C 拿到 A 对象后顺利完成初始化，然后将自己添加到一级缓存中

回到 B ，B 也可以拿到 C 对象，完成初始化，A 可以顺利拿到 B 完成初始化。到这里整个链路就已经完成了初始化过程了

如下是《Spring 源码深度解析》P114 页的一张图，非常有助于理解。

参照：https://www.jianshu.com/p/8bb67ca11831

最新回复(0)