从一部电影史上的趣事了解 Spring 中的循环依赖问题

---

title: 从一部电影史上的趣事了解 Spring 中的循环依赖问题

date: 2021-03-10

updated: 2021-03-10

categories:

• Spring
  
  tags:
• Spring

---

前言

今天，我们从电影史上一则有趣的故事来了解 Spring 中的循环依赖问题。

---

---

1998 年的某一天，《喜剧之王》和《玻璃樽》两部电影进入了拍摄阶段。

在《喜剧之王》需要成龙友情客串一个替身演员，而《玻璃樽》需要周星驰客串一个被警犬拖着的警察。

那么，我们想象一下：如果当《喜剧之王》在香港开拍时，《玻璃樽》剧组还在广州，会怎么样？

在现实生活中，我们可能会调整时间安排来解决这种戏份冲突的问题，但在 Spring 对象加载过程中，对象的加载是顺序性的，并不能像我们现实生活中那么灵活。

我们将《喜剧之王》和《玻璃樽》分别看做对象 A 和对象 B，将周星驰和成龙分别看做对象 A 中的 资源 x 和对象 B 中的资源 y。

• 《喜剧之王》（对象 A）中需要成龙（对象 B 中的资源 y）客串完成。

• 《玻璃樽》（对象 B）中需要周星驰（对象 A 中的资源 x）客串完成。

也就是说：对象 A 加载时，需要存在对象 B，对象 A 才能顺利加载。而对象 B 的加载也是相同的情况。

但由于对象 A 和对象 B 加载顺序一定是一前一后，所以如果不做一定处理，加载是一定不成功的。这也就是我们所说的循环依赖问题。

前置条件

在 Spring 解决循环依赖是有前置条件的：

1. 出现循环依赖的 Bean 必须是单例
2. 依赖注入的方式不能全是构造器注入的方式

那么，Spring 如何解决循环依赖问题的呢？这个问题有些抽象，下面举例说明。

测试循环依赖报错问题

测试使用的依赖：

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.4.0</version>
  </dependency>
</dependencies>

创建启动类

@SpringBootApplication
public class SpringApplication {

  public static void main(String[] args) {
    org.springframework.boot.SpringApplication.run(SpringApplication.class, args);
  }
}

创建以下两个类 A、B，其中 A 依赖 B，B 依赖 A。

@Component
public class A {

  private final CircularB circularB;

  public CircularA(CircularB circularB) {
    this.circularB = circularB;
  }
}

@Component
public class B {

  private final CircularA circularA;

  public CircularB(CircularA circularA) {
    this.circularA = circularA;
  }
}

启动应用，发现如下报错。

2021-03-10 20:18:52.637  INFO 38500 --- [           main] ConditionEvaluationReportLoggingListener : 

Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled.
2021-03-10 20:18:52.652 ERROR 38500 --- [           main] o.s.b.d.LoggingFailureAnalysisReporter   : 

***************************
APPLICATION FAILED TO START
***************************

Description:

The dependencies of some of the beans in the application context form a cycle:

┌─────┐
|  circularA defined in file [/Users/lihuiming/git/xs/xs-learning/xs-learning-spring/target/classes/com/xs/learning/spring/dependency/CircularA.class]
↑     ↓
|  circularB defined in file [/Users/lihuiming/git/xs/xs-learning/xs-learning-spring/target/classes/com/xs/learning/spring/dependency/CircularB.class]
└─────┘

Bean 的创建流程

首先，我们根据源码了解一下 Bean 的创建流程：

• AbstractBeanFactory#getBean()
• AbstractBeanFactory#doGetBean(a)

  • DefaultSingletonBeanRegistry#getSingleton(beanName)

    • getSingleton(beanName, true)

      • singletonObjects：一级缓存尝试获取目标对象。存储的是所有创建好了的单例 Bean。

      • earlySingletonObjects：二级缓存尝试获取目标对象。对象完成实例化，但未进行属性注入及初始化的对象。

      • singletonFactories：三级缓存尝试获取目标对象。若获取到对象，将对象从三级缓存中删除，并放入二级缓存。

  • if (sharedInstance != null && args == null)

    • mbd.isSingleton()：创建单例 Bean

      • AbstractAutowireCapableBeanFactory#createBean(beanName, mbd, args)
        • doCreateBean(beanName, mbdToUse, args)
          • createBeanInstance(beanName, mbd, args)：创建 Bean 实例
          • allowCircularReferences：允许循环引用
          • isSingletonCurrentlyInCreation(beanName)：查找 beanName 是否在创建中的集合内。
          • getEarlyBeanReference(beanName, mbd, bean)：循环获取二级缓存中的对象引用
          • addSingletonFactory(beanName, singletonFactory)：将对象放入一级缓存
      • DefaultSingletonBeanRegistry#getSingleton(beanName, true)
        • beforeSingletonCreation(beanName)：判断是否需要跳过检查，以及将 beanName 添加到创建中的集合。
        • afterSingletonCreation(beanName)：判断是否需要跳过检查，以及将 beanName 从创建中的集合移除。
      • getObjectForBeanInstance(sharedInstance, name, beanName, mbd)：完成单例 Bean 的创建

    • mbd.isPrototype()：创建原型 Bean

      • beforePrototypeCreation(beanName)
        • prototypesCurrentlyInCreation.get()：获取当前线程的创建对象信息
        • if (curVal == null)：若创建对象信息为 null
          • prototypesCurrentlyInCreation.set(beanName)：设置当前线程的创建对象信息为 beanName
        • else if (curVal instanceof String)：若实例对象为 String 类型
          • beanNameSet.add((String)curVal)：将现有对象转为字符串存储
          • beanNameSet.add(beanName)：将当前 beanName 追加到集合中
          • prototypesCurrentlyInCreation.set(beanNameSet)：，设置当前线程的创建对象信息为集合对象
        • else
          • beanNameSet.add(beanName)：在当前线程的创建对象信息中追加 beanName
      • AbstractAutowireCapableBeanFactory#createBean(beanName, mbd, args)：与单例 Bean 对应方法一致
      • afterPrototypeCreation(beanName)
        • prototypesCurrentlyInCreation.get()：获取当前线程的创建对象信息
        • if (curVal instanceof String)：若当前线程的创建对象信息为 String
          • prototypesCurrentlyInCreation.remove()：移除当前线程的创建对象信息
        • else if (curVal instanceof Set)：若当前线程的创建对象信息为 Set 集合
          • beanNameSet.remove(beanName)：移除当前线程的创建对象信息中指定 beanName
          • if (beanNameSet.isEmpty())：若 Set 集合为空
            • prototypesCurrentlyInCreation.remove()：移除当前线程的创建对象信息
      • getObjectForBeanInstance(prototypeInstance, name, beanName, mbd)：完成原型 Bean 的创建

    • mbd.getScope()：根据作用域创建 Bean

      • if (scope == null)：找不到对应的 Scope 报错
      • beforePrototypeCreation(beanName)：与原型 Bean 对应方法一致
      • AbstractAutowireCapableBeanFactory#createBean(beanName, mbd, args)：与单例 Bean 对应方法一致
      • afterPrototypeCreation(beanName)：与原型 Bean 对应方法一致
      • scope.get(beanName, objectFactory)：获取 Scope 实例
      • getObjectForBeanInstance(scopedInstance, name, beanName, mbd)：完成 Scope Bean 的创建

如上所示，这就是一次 Bean 的创建流程。

循环依赖的解决办法

有两种办法：

1. 将上述测试代码中，先加载的对象（也就是对象 A）改为注解注入的方式。
2. 将上述测试代码中，将两个对象都改为注解注入的方式。

注意：如果只修改一个对象的注入方式，一定要修改加载顺序靠前的对象，否则无法解决循环依赖问题！

@Component
public class A {

  @Autowired
  private CircularB circularB;
}

@Component
public class B {

  private final CircularA circularA;

  public CircularB(CircularA circularA) {
    this.circularA = circularA;
  }
}

循环依赖的运行过程

1. 首先根据 Spring 自然排序规则，先去获取 A 对象实例，第一次获取会发现缓存中没有 A 实例对象，返回 null；
2. 由于未获取到 A 对象实例，进行创建 A 对象实例；
3. 创建 A 对象实例时，发现 A 对象依赖 B 对象，循环获取二级缓存中的对象引用，尝试获取 B 对象实例来注入到 A 对象实例中；
4. 由于缓存中没有 B 对象实例，所以会创建 B 对象实例；
5. 此时，A 对象实例获取得到 B 对象实例（已实例化，但未注入属性信息，未初始化），A 对象实例加载完成；
6. 创建 B 对象实例时，发现 B 对象依赖 A 对象，获取 A 对象实例来注入到 B 对象实例中；
7. 此时，B 对象实例加载完成；