Spring 三级缓存设计哲学#

// 没有 AOP 切面时
Map<String, Object> singletonObjects = new HashMap<>();        // 一级
Map<String, Object> earlySingletonObjects = new HashMap<>();   // 二级
// 只需要两级就够了！工厂不需要了，直接在实例化后把对象放入二级缓存

// ❌ 两级缓存方案
// A 实例化后，直接创建代理存入二级缓存
Object proxyA = createProxy(aInstance);  // 假设这里能创建代理
earlySingletonObjects.put("A", proxyA);

// B 属性注入时拿到的是 A 的代理
B b = new B();
b.setA(getEarlySingleton("A"));  // 获取到的是早期代理

// A 初始化完成后... 怎么替换掉早期代理？
// 问题：谁持有 A 的引用？谁来触发替换？

// 三级缓存的关键设计
// 不是"实例化后立即创建代理"
// 而是"需要时才创建代理"

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        Object singletonInstance = this.singletonObjects.get(beanName);
        if (singletonInstance == null) {
            // 回调工厂获取对象
            singletonInstance = singletonFactory.getObject();
            // 放入缓存
            this.singletonObjects.put(beanName, singletonInstance);
        }
        return singletonInstance;
    }
}

// Spring 中的工厂方法定义
@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

// addSingletonFactory 的调用点
// 在 doCreateBean 中，实例化后立即调用
boolean earlySingletonExposure = mbd.isSingleton()
    && this.allowCircularReferences
    && isSingletonCurrentlyInCreation(beanName);

if (earlySingletonExposure) {
    addSingletonFactory(beanName,
        () -> getEarlyBeanReference(beanName, mbd, bean));
}

// getEarlyBeanReference 负责创建早期引用（可能是代理）
protected Object getEarlyBeanReference(String beanName,
                                         RootBeanDefinition mbd,
                                         Object bean) {
    Object exposedObject = bean;
    // 如果需要 AOP 代理，在这里创建
    if (mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        // 遍历所有后置处理器，检查是否需要创建代理
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof AbstractAutoProxyCreator) {
                AbstractAutoProxyCreator proxyCreator =
                    (AbstractAutoProxyCreator) bp;
                // 检查切面是否匹配这个 Bean
                if (proxyCreator.shouldProxy(bean, beanName)) {
                    exposedObject = proxyCreator.getEarlyBeanReference(
                        bean, beanName);
                    break;
                }
            }
        }
    }
    return exposedObject;
}

// 场景：多个 Bean 同时循环依赖同一个 Bean
// A 和 C 都依赖 B

// A 创建时
B b = singletonFactory.getObject();  // 第一次调用，创建代理 B1
earlySingletonObjects.put("B", b);

// C 创建时
B b2 = earlySingletonObjects.get("B");  // 直接从二级缓存取
// 不会再次调用 factory.getObject()

// 如果只有三级缓存：
// A 创建时，放入工厂
// C 创建时，又调用 factory.getObject() → 又创建一个代理 B2！
// B 出现了两个不同的代理对象！

// ❌ 假设实例化后立即创建代理
BeanWrapper wrapper = createBeanInstance(beanName, mbd, args);
Object proxy = createProxy(wrapper.getWrappedInstance(), beanName);
// 此时属性还没注入，AspectJ 无法判断某些切点是否匹配
// 因为被代理对象的状态还不完整

// Spring 5.x 引入了 getEarlyBeanReference 回调
// 它是 SmartInstantiationAwareBeanPostProcessor 的方法
public interface SmartInstantiationAwareBeanPostProcessor
        extends InstantiationAwareBeanPostProcessor {

    // 在实例化后、属性注入前，预测 Bean 的类型
    Object predictBeanType(Class<?> beanClass, String beanName);

    // 获取早期引用（用于循环依赖）
    Object getEarlyBeanReference(Object bean, String beanName);
}

// 构造器注入：实例化 = 构造器调用 = 需要依赖
// 此时根本还没进入 Spring 的创建流程！

// setter 注入：实例化 = 构造函数执行（不需要依赖）
// 实例化完成后才进行属性注入
// 在属性注入前，有机会暴露工厂

// Spring 构造函数实例化支持两种模式：
// 1. 构造函数注入（autowire = constructor）
// 2. 普通构造函数

// 无论哪种，构造函数的执行都在 createBeanInstance 中完成
protected BeanWrapper createBeanInstance(String beanName, ...) {
    Constructor<?> constructorToUse;
    ConstructorResolver.resolvePreparedArguments(...);
    return new BeanWrapperImpl(
        instantiationStrategy.instantiate(mbd, beanName, constructorToUse, args)
    );
    // ↑ new A(b) 在这里执行
    // 如果构造器需要 B 参数... B 参数的获取不在 Spring 控制下！
}

// 而 setter 注入是在 populateBean 中：
protected void populateBean(String beanName, RootBeanDefinition mbd, ...) {
    // 这里已经完成实例化了
    // 注入 Aware 接口
    // 注入属性
    applyPropertyValues(beanName, mbd, bw, pvs);  // ← 注入在这里发生
}