Spring 循环依赖：三级缓存解决方案

// Spring 尝试创建 A
1. new ServiceA()  // 实例化 A（空对象）
2. 填充 A 的属性 → 发现需要 ServiceB
3.   new ServiceB()  // 实例化 B
4.   填充 B 的属性 → 发现需要 ServiceA
5.     new ServiceA()  // 又去创建 A → 回到步骤 1 → 无限循环！

public class DefaultSingletonBeanRegistry {

    /** 一级缓存：存放完全初始化好的单例 Bean */
    private final Map<String, Object> singletonObjects
            = new ConcurrentHashMap<>(256);

    /** 二级缓存：存放提前暴露的半成品 Bean（已实例化，未填充属性） */
    private final Map<String, Object> earlySingletonObjects
            = new ConcurrentHashMap<>(16);

    /** 三级缓存：存放 Bean 工厂对象（ObjectFactory），用于生成早期引用 */
    private final Map<String, ObjectFactory<?>> singletonFactories
            = new HashMap<>(16);
}

========== 第一步：创建 A ==========

1. 实例化 A：new ServiceA()  → 得到空对象 A'
2. 将 A' 包装成 ObjectFactory，放入 三级缓存：
   singletonFactories.put("serviceA", () -> getEarlyBeanReference(A'))

========== 第二步：填充 A 的属性 ==========

3. 发现 A 需要 ServiceB → 去获取 B
4. 实例化 B：new ServiceB()  → 得到空对象 B'
5. 将 B' 包装成 ObjectFactory，放入 三级缓存

========== 第三步：填充 B 的属性（关键！） ==========

6. 发现 B 需要 ServiceA → 去获取 A
7. getSingleton("serviceA")：
   一级缓存？没有
   二级缓存？没有
   三级缓存？有！调用 ObjectFactory.getObject()
   → 如果需要 AOP，这里返回代理对象；否则返回 A'
   → 将结果放入 二级缓存，从三级缓存移除
8. B 拿到了 A 的早期引用（A' 或代理），完成属性填充和初始化
9. B 初始化完成 → 放入 一级缓存

========== 第四步：A 完成创建 ==========

10. A 拿到完整的 B → 完成属性填充
11. A 初始化完成 → 放入 一级缓存
12. 清理二级缓存中 A 的早期引用

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // ① 先查一级缓存：成品 Bean
    Object singletonObject = this.singletonObjects.get(beanName);

    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // ② 查二级缓存：提前暴露的半成品
        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) {
                        // ③ 查三级缓存：调用工厂生成对象
                        ObjectFactory<?> factory =
                                this.singletonFactories.get(beanName);
                        if (factory != null) {
                            // 关键：这里会触发 AOP 代理创建
                            singletonObject = factory.getObject();
                            // 升级到二级缓存
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            // 从三级缓存移除
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

// 假设 ServiceA 被 @Transactional 标注，需要生成代理

// 只有二级缓存的情况：
1. 实例化 A → A'（原始对象）
2. 放入二级缓存：earlySingletonObjects.put("serviceA", A')
3. 创建 B，B 需要 A → 从二级缓存拿到 A'（原始对象）
4. A 初始化时生成代理 → ProxyA
5. 问题！B 持有的是 A'，而不是 ProxyA → 事务失效！

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object actualBean = bean;
    if (bean != null) {
        // 检查缓存中是否已有早期引用
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.containsKey(cacheKey)) {
            // 关键！遍历所有 SmartInstantiationAwareBeanPostProcessor
            // 如果 Bean 需要 AOP 代理，这里会返回代理对象
            actualBean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
        }
    }
    return actualBean; // 可能是原始对象，也可能是代理对象
}

@Service
public class ServiceA {
    private final ServiceB b;
    public ServiceA(ServiceB b) { this.b = b; } // 构造器注入
}

@Service
public class ServiceB {
    private final ServiceA a;
    public ServiceB(ServiceA a) { this.a = a; } // 构造器注入
}

// 创建过程：
1. 要 new ServiceA → 需要 ServiceB 作为参数
2. 要 new ServiceB → 需要 ServiceA 作为参数
3. 要 new ServiceA → ...  → BeanCurrentlyInCreationException!

@Service
public class ServiceA {
    private final ServiceB b;
    public ServiceA(@Lazy ServiceB b) {
        this.b = b; // 注入的是代理，不会触发 B 的创建
    }
}

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

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

   serviceA
      ↓
   serviceB
      ↓
   serviceA
// BeanCurrentlyInCreationException

spring:
  main:
    allow-circular-references: true  # 不推荐，仅作为迁移过渡