Spring 循环依赖问题解决方案以及简要源码流程剖析

public class CircularTest {
    public static void main(String[] args) {
        A a = new A();
    }
    static class A {
        private B classTwo = new B();
    }
    static class B {
        private A classOne = new A();
    }
}

Exception in thread "main" java.lang.StackOverflowError
  at com.vnjohn.cyclereference.CircularTest$B.<init>(CircularTest.java:17)
  at com.vnjohn.cyclereference.CircularTest$A.<init>(CircularTest.java:13)
  at com.vnjohn.cyclereference.CircularTest$B.<init>(CircularTest.java:17)
  at com.vnjohn.cyclereference.CircularTest$A.<init>(CircularTest.java:13)
  at com.vnjohn.cyclereference.CircularTest$B.<init>(CircularTest.java:17)
  at com.vnjohn.cyclereference.CircularTest$A.<init>(CircularTest.java:13)
  at com.vnjohn.cyclereference.CircularTest$B.<init>(CircularTest.java:17)
  at com.vnjohn.cyclereference.CircularTest$A.<init>(CircularTest.java:13)
  at com.vnjohn.cyclereference.CircularTest$B.<init>(CircularTest.java:17)

public class CircularTest {
    private static final Map<String, Object> map = new ConcurrentHashMap<>();
    public static void main(String[] args) throws Exception {
        System.out.println(getBean(A.class));
        System.out.println(getBean(B.class));
    }
    public static <T> T getBean(Class<T> tClass) throws Exception {
        Object object = tClass.newInstance();
        String tClassName = tClass.getSimpleName();
        if (map.containsKey(tClassName)) {
            return (T) map.get(tClassName);
        }
        // 将半成品对象放入到容器中
        map.put(tClassName, object);
        for (Field field : tClass.getDeclaredFields()) {
            field.setAccessible(true);
            String fieldClassName = field.getType().getSimpleName();
            // 插入一个逻辑，判断是否有该属性对应对象的半成品对象
            Class<?> fieldClass = field.getType();
            // 递归调用 getBean 方法
            field.set(object, map.containsKey(fieldClassName) ? map.get(fieldClassName) : getBean(fieldClass));
        }
        return (T) object;
    }
    public static class A {
        private B b;
        public B getB() {
            return b;
        }
        public void setB(B b) {
            this.b = b;
        }
    }
    public static class B {
        private A a;
        public A getA() {
            return a;
        }
        public void setA(A a) {
            this.a = a;
        }
    }
}

com.vnjohn.Test1$A@26f0a63f
com.vnjohn.Test1$B@4361bd48

// 判断当前bean是否需要提前曝光：单例&允许循环依赖&当前 bean 正在创建中（创建时会记录状态，创建完会移除状态），检测循环依赖
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                  isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
    if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
                     "' to allow for resolving potential circular references");
    }
    // 为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(singletonFactory, "Singleton factory must not be null");
  // 使用 singletonObjects 进行加锁，保证线程安全
  synchronized (this.singletonObjects) {
    // 如果单例对象的高速缓存【beanName->bean 实例】没有该 Bean 存在
    if (!this.singletonObjects.containsKey(beanName)) {
      // 将 beanName->singletonFactory 放到单例工厂的缓存【bean名称->ObjectFactory】
      this.singletonFactories.put(beanName, singletonFactory);
      // 从早期单例对象的高速缓存【beanName->bean 实例】 移除 beanName 相关缓存对象
      this.earlySingletonObjects.remove(beanName);
      // 将 beanName 添加已注册的单例集中
      this.registeredSingletons.add(beanName);
    }
  }
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   // 从单例对象缓存中获取 beanName 对应的单例对象
   Object singletonObject = this.singletonObjects.get(beanName);
   // 若单例对象缓存中没有，并且该 beanName 对应单例 bean 正在创建中
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      // 从早期单例对象缓存中获取单例对象（
      // 之所以称之为早期单例对象，是因为 earlySingletonObjects 里对象都是
      // 通过提前曝光的 ObjectFactory 创建出来的，还未进行属性填充等操作的
      singletonObject = this.earlySingletonObjects.get(beanName);
      // 若在早期单例对象缓存中也没有，并且允许创建早期单例对象引用
      if (singletonObject == null && allowEarlyReference) {
         // 如果为空，则锁定全局变量并进行处理
         synchronized (this.singletonObjects) {
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               singletonObject = this.earlySingletonObjects.get(beanName);
               if (singletonObject == null) {
                  // 当某些方法需要提前初始化的时候则会调用 addSingletonFactory 方法
                  // 将对应 ObjectFactory 初始化策略存储在 singletonFactories
                  ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                  if (singletonFactory != null) {
                     // 若存在单例对象工厂，则通过工厂创建一个单例对象
                     singletonObject = singletonFactory.getObject();
                     // 记录在缓存中，二级缓存、三级缓存的对象不能同时存在
                     this.earlySingletonObjects.put(beanName, singletonObject);
                     // 从三级缓存中移除
                     this.singletonFactories.remove(beanName);</mark>
                  }
               }
            }
         }
      }
   }
   return singletonObject;
}

protected void addSingleton(String beanName, Object singletonObject) {
  synchronized (this.singletonObjects) {
    // 将映射关系添加到单例对象的高速缓存中
    this.singletonObjects.put(beanName, singletonObject);
    // 移除 beanName 在单例工厂缓存中的数据
    this.singletonFactories.remove(beanName);
    // 移除 beanName 在早期单例对象的高速缓存的数据
    this.earlySingletonObjects.remove(beanName);
    // 将beanName添加到已注册的单例集中
    this.registeredSingletons.add(beanName);
  }
}