Java Spring 循环依赖解析

public class T1 {

  class A {
    B b;
  }
  class B {
    C c;
  }
  class C {
    A a; 
  }
}

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

@Component
public class B {
    @Autowired
    private C c;
}
 
@Component
public class C {
    @Autowired
    private A a;
}

@Component
public class ServiceA{

    private ServiceB serviceB;
        
    public ServiceA(ServiceB serverB) {
       this.serivceB = serviceB;
    }     
}

@Component
public class ServiceB{

    private ServiceA serviceA;
        
    public ServiceB(ServiceA serviceA) {
       this.serviceA = serviceA;
    }     
}

@Component
public class ServiceA{

    private ServiceB serviceB;
        
    public setServiceB(ServiceB serverB) {
       this.serivceB = serviceB;
    }     
}

@Component
public class ServiceB{

    private ServiceA serviceA;
        
    public setServiceB(ServiceA serviceA) {
       this.serviceA = serviceA;
    }     
}

@Data
public class A{
  private B b;
  
  public A() {
     System.out.println("----- A create success");
  }
}

@Data
public class B{
  private a a;

  public B() {
     System.out.println("------ B create success");
  }    
}

A a = new A();
B b = new B();

a.setB(b);
b.setA(a);

@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class A {

    @Autowired
    private B b;
}

@Component
public class B {

    @Autowired
    private A a;
}

// 增加注解
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

class BTest {


    @Configuration
    @Import({A.class, B.class})
    public static class TestConfig {

    }

    @Test
    public void currentlyincreation() {
        AnnotationConfigApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(TestConfig.class);
        // 这里要获取 bean 一下，如果不去主动获取，可能是由于惰性加载没有执行，不会报错
        A a = applicationContext.getBean(A.class);
        System.out.println(a);
    }
}

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);


private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);


private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

@FunctionalInterface
public interface ObjectFactory<T> {

    
    T getObject() throws BeansException;

}

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从 singletonObject 获取实例，singletonObject 中的实例都是准备好的 bean 实例
    Object singletonObject = this.singletonObjects.get(beanName);
    // isSingletonCurrentlyInCreation() 判断当前单例 bean 是否正在创建中
    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;
}