循环依赖与三级缓存#

// 1. 字段注入循环依赖
@Service
public class A {
    @Autowired private B b;
}
@Service
public class B {
    @Autowired private A a;
}

// 2. setter 注入循环依赖
@Service
public class A {
    private B b;
    @Autowired
    public void setB(B b) { this.b = b; }
}
@Service
public class B {
    private A a;
    @Autowired
    public void setA(A a) { this.a = a; }
}

// 3. 构造器循环依赖（Spring 无法解决）
@Service
public class A {
    private B b;
    public A(B b) { this.b = b; }
}
@Service
public class B {
    private A a;
    public B(A a) { this.a = a; }
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry {

    // 一级缓存：完全初始化好的 Bean（可以直接使用）
    private final Map<String, Object> singletonObjects =
        new ConcurrentHashMap<>(256);

    // 二级缓存：提前曝光的 Bean（实例已创建，但属性未注入）
    private final Map<String, Object> earlySingletonObjects =
        new ConcurrentHashMap<>(256);

    // 三级缓存：Bean 的早期工厂（用于创建早期引用的回调）
    private final Map<String, ObjectFactory<?>> singletonFactories =
        new ConcurrentHashMap<>(256);

    // 正在创建中的 Bean 名称集合
    private final Set<String> singletonsCurrentlyInCreation =
        Collections.newSetFromMap(new ConcurrentHashMap<>(16));
}

public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 先查一级缓存：已完全初始化的单例
    Object singletonObject = singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 2. 一级缓存没有，正在创建中，查二级缓存
        synchronized (this.singletonObjects) {
            singletonObject = earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 3. 二级缓存没有，查三级缓存并升级
                ObjectFactory<?> singletonFactory = singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();  // 调用回调
                    // 升级到二级缓存
                    earlySingletonObjects.put(beanName, singletonObject);
                    // 删除三级缓存
                    singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

// ❌ 一级缓存的问题
Map<String, Object> singletonObjects = new HashMap<>();

// 线程 A 创建 A 属性注入时需要 B，去创建 B
// 线程 A 创建 B 属性注入时需要 A，此时去一级缓存找 A
// 问题：一级缓存里没有 A（A 还在创建中，没有完成）
// 结果：死循环 or NPE

// ❌ 两级缓存的问题
Map<String, Object> singletonObjects = new HashMap<>();
Map<String, Object> earlySingletonObjects = new HashMap<>();

// A 属性注入时需要 B，去创建 B
// B 属性注入时需要 A，去一级缓存找 A → 没有（A 还在创建）
// 去二级缓存找 A → 没有（A 还没有创建！）
// 问题：二级缓存里也没有，因为 A 还没开始创建

// ✅ 三级缓存的关键：提前暴露工厂

// 1. A 开始创建，调用 addSingletonFactory
protected void addSingletonFactory(String beanName,
                                   ObjectFactory<?> singletonFactory) {
    if (!this.singletonObjects.containsKey(beanName)) {
        // 把工厂放入三级缓存
        this.singletonFactories.put(beanName, singletonFactory);
        // 注意：此时一级和二级缓存都没有 A
    }
}

// 2. A 实例化完成后，立即暴露工厂（此时 B 可以通过工厂获取 A 的早期引用）
// 在 doCreateBean 中：
boolean earlySingletonExposure = mbd.isSingleton()
    && this.allowCircularReferences
    && isSingletonCurrentlyInCreation(beanName);

if (earlySingletonExposure) {
    addSingletonFactory(beanName,
        () -> getEarlyBeanReference(beanName, mbd, bean));  // ← 三级缓存存的就是这个
}

// 3. B 在属性注入时发现需要 A，去调用 getSingleton("A")
// getSingleton 查一级 → 没有（因为 A 还没创建完）
// 查二级 → 没有
// 查三级 → 有！调用 singletonFactory.getObject() → getEarlyBeanReference("A")
// getEarlyBeanReference 返回 A 的早期引用（可能已经被代理）
// B 拿到 A 的早期引用，继续创建 → B 创建完成
// 回到 A，继续属性注入 → A 创建完成

// 如果只有三级缓存：
// B 获取 A 的早期引用 → 调用 factory.getObject() → 创建代理
// C 获取 A 的早期引用 → 又调用 factory.getObject() → 又创建代理
// 同一个 Bean 被创建了两次代理！

// 有二级缓存后：
// B 获取 A 的早期引用 → 调用 factory.getObject() → 创建代理 → 存入二级缓存
// C 获取 A 的早期引用 → 查二级缓存 → 直接取已有的代理 → 不会重复创建

// 构造器注入的循环依赖
@Service
public class A {
    private B b;
    public A(B b) {  // 构造器需要 B
        this.b = b;
    }
}

@Service
public class B {
    private A a;
    public B(A a) {  // 构造器需要 A
        this.a = a;
    }
}

// doCreateBean 中暴露工厂的时机：
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
// ↑ 实例化完成后

boolean earlySingletonExposure = mbd.isSingleton()
    && this.allowCircularReferences
    && isSingletonCurrentlyInCreation(beanName);

if (earlySingletonExposure) {
    addSingletonFactory(beanName, ...);  // ← 这里才暴露工厂
}

// 但构造器注入的"实例化"发生在 new A(B b) 那一刻
// 此时 A 还没有进入 doCreateBean，还没有暴露工厂
// 所以 B 无法从三级缓存获取 A 的早期引用

// prototype Bean 每次 getBean 都创建新实例，不走三级缓存
@Override
public Object getBean(String name, Object... args) {
    for (String beanName : beanDefinitionNames) {
        if (mbd.isPrototype()) {
            // prototype 不注册到 singletonFactories
            // 每次都是新创建，无法通过缓存解决
            return createBean(beanName, mbd, args);
        }
    }
}

// 默认 allowCircularReferences = true
// 如果关闭，循环依赖会直接抛异常
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    if (!allowEarlyReference) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
    // ...
}

// DefaultSingletonBeanRegistry.getSingleton
ObjectFactory<?> singletonFactory = singletonFactories.get(beanName);
if (singletonFactory != null) {
    singletonObject = singletonFactory.getObject();
    earlySingletonObjects.put(beanName, singletonObject);  // 升级到二级
    singletonFactories.remove(beanName);  // 必须删除三级
    // 否则下次还会调用工厂，创建重复代理
}