彻底搞懂 Spring 循环依赖什么是循环依赖以及循环依赖的方式，从源码角度分析Spring如何解决循环依赖，为什么需要

什么是循环依赖

互相引用，形成一个环。

依赖方式

Bean的创建

根据直接互相依赖展示流程

要解决循环依赖，就得解决第二次A创建过程

Spring 如何解决的？

依赖的三级缓存

// 一级
/** Cache of singleton objects: bean name to bean instance. */
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 三级
  /** Cache of singleton factories: bean name to ObjectFactory. */
  private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

// 二级
  /** Cache of early singleton objects: bean name to bean instance. */
  private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

示例代码

@Component
public class A {
  @Autowired
  private B b;
}

@Component
public class B {
  @Autowired
  private A a;
}
@ComponentScan(basePackages = {"com.wl.anination"})
public class Config {
}

Spring 代码梳理

具体创建 bean 的过程此处不再讲解，请参考文章 Spring 源码之 Bean 的创建。

Spring源码之Bean的创建（一）

Spring 源码之 Bean的创建（二）

创建A

Object sharedInstance = getSingleton(beanName); // 从容器获取【AbstractBeanFactory.doGetBean】

获取为空：

beforeSigletonCreation，记录当前bean正在创建

markBeanAsCreated，放置于alreadyCreated

doCreateBean创建A

判断正在创建中：加入三级缓存

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

populateBean 设置属性

发现需要设置属性B，从容器重获取，首次没有，此时创建B，到 2
获取到B 设置属性值

创建B，流程同A

Object sharedInstance = getSingleton(beanName); // 从容器获取【AbstractBeanFactory.doGetBean】

获取为空：

beforeSigletonCreation，记录当前bean正在创建

markBeanAsCreated，放置于alreadyCreated

doCreateBean创建A

判断正在创建中：加入三级缓存

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

populateBean 设置属性

发现需要设置属性A,从容器获取

getSingleton：从一级取，从二级取，最后从三级取，三级取到时放到二级缓存并删除三级缓存

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // Quick check for existing instance without full singleton lock
    // 一级缓存取
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      // 一级缓存没有且正在创建，从二级取
      singletonObject = this.earlySingletonObjects.get(beanName);
      if (singletonObject == null && allowEarlyReference) {
        // 二级也没有，加锁
        synchronized (this.singletonObjects) {
          // Consistent creation of early reference within full singleton lock
          // 从一级取
          singletonObject = this.singletonObjects.get(beanName);
          if (singletonObject == null) {
            // 从二级取
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null) {
              // 三级取
              ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
              if (singletonFactory != null) {
                singletonObject = singletonFactory.getObject();
                // 获取对象，删除三级缓存，放至二级缓存
                this.earlySingletonObjects.put(beanName, singletonObject);
                this.singletonFactories.remove(beanName);
              }
            }
          }
        }
      }
    }
    return singletonObject;
  }