【 手撕Java源码专栏 】深入理解Spring三级缓存:从源码到实践,彻底解决循环依赖

// A依赖B@Servicepublic classServiceA{    @Autowired    private ServiceB serviceB;}// B依赖A@Servicepublic classServiceB{    @Autowired    private ServiceA serviceA;}

/** * 对象工厂接口，用于创建Bean的早期引用 */public interface CustomObjectFactory<T> {    /**     * 获取Bean实例     * @return Bean实例     */    T getObject();}

/** * 自定义单例Bean注册表，实现Spring的三级缓存机制 */public class CustomSingletonBeanRegistry {    // 一级缓存：存储完全初始化好的单例Bean    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);    // 二级缓存：存储早期曝光的Bean实例（尚未完成属性注入）    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);    // 三级缓存：存储Bean工厂对象，用于生成Bean的早期引用    private final Map<String, CustomObjectFactory<?>> singletonFactories = new HashMap<>(16);    // 正在创建中的Bean集合    private final Set<String> singletonsCurrentlyInCreation =         Collections.newSetFromMap(new ConcurrentHashMap<>(16));    // 已注册的Bean名称集合    private final Set<String> registeredSingletons =         Collections.newSetFromMap(new ConcurrentHashMap<>(256));    // 排除检查的Bean名称集合    private final Set<String> inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>(16));    /**     * 获取单例Bean（核心方法）     */    @SuppressWarnings("unchecked")    public Object getSingleton(String beanName) {        // 1. 先从一级缓存获取        Object singletonObject = this.singletonObjects.get(beanName);        // 2. 如果一级缓存中不存在，且当前Bean正在创建中        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {            synchronized (this.singletonObjects) {                // 3. 从二级缓存获取早期引用                singletonObject = this.earlySingletonObjects.get(beanName);                if (singletonObject == null) {                    // 4. 从三级缓存获取工厂对象                    CustomObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);                    if (singletonFactory != null) {                        // 5. 通过工厂获取早期Bean引用                        singletonObject = singletonFactory.getObject();                        // 6. 将早期引用放入二级缓存                        this.earlySingletonObjects.put(beanName, singletonObject);                        // 7. 从三级缓存移除工厂对象                        this.singletonFactories.remove(beanName);                    }                }            }        }        return singletonObject;    }    /**     * 注册单例Bean（完全初始化后的Bean）     */    public void registerSingleton(String beanName, Object singletonObject) {        synchronized (this.singletonObjects) {            // 放入一级缓存            this.singletonObjects.put(beanName, singletonObject);            // 从二级缓存移除            this.earlySingletonObjects.remove(beanName);            // 从三级缓存移除            this.singletonFactories.remove(beanName);            // 注册Bean名称            this.registeredSingletons.add(beanName);        }    }    /**     * 添加单例工厂（用于创建早期引用）     */    public void addSingletonFactory(String beanName, CustomObjectFactory<?> singletonFactory) {        synchronized (this.singletonObjects) {            // 只有当一级缓存中不存在时，才添加到三级缓存            if (!this.singletonObjects.containsKey(beanName)) {                this.singletonFactories.put(beanName, singletonFactory);                this.earlySingletonObjects.remove(beanName);            }        }    }    /**     * 标记Bean为正在创建中     */    public void beforeSingletonCreation(String beanName) {        if (!this.inCreationCheckExclusions.contains(beanName) &&             !this.singletonsCurrentlyInCreation.add(beanName)) {            throw new RuntimeException("Bean with name '" + beanName + "' is currently in creation: " +                "Is there an unresolvable circular reference?");        }    }    /**     * 标记Bean创建完成     */    public void afterSingletonCreation(String beanName) {        if (!this.inCreationCheckExclusions.contains(beanName) &&             !this.singletonsCurrentlyInCreation.remove(beanName)) {            throw new RuntimeException("Singleton '" + beanName + "' isn't currently in creation");        }    }    /**     * 检查Bean是否正在创建中     */    public boolean isSingletonCurrentlyInCreation(String beanName) {        return this.singletonsCurrentlyInCreation.contains(beanName);    }}

/** * 自定义Bean工厂，用于创建和管理Bean */public class CustomBeanFactory {    // 使用我们的自定义单例Bean注册表    private final CustomSingletonBeanRegistry singletonRegistry = new CustomSingletonBeanRegistry();    // 存储Bean定义的映射    private final Map<String, BeanDefinition<?>> beanDefinitions = new HashMap<>();    /**     * 注册Bean定义     */    public <T> void registerBean(String beanName, Class<T> beanClass, String... dependencies) {        BeanDefinition<T> definition = new BeanDefinition<>(beanClass, dependencies);        beanDefinitions.put(beanName, definition);    }    /**     * 获取Bean实例（核心方法）     */    @SuppressWarnings("unchecked")    public <T> T getBean(String beanName) {        // 1. 先尝试从单例缓存中获取        Object bean = singletonRegistry.getSingleton(beanName);        if (bean != null) {            return (T) bean;        }        // 2. 如果缓存中没有，开始创建Bean        BeanDefinition<T> definition = (BeanDefinition<T>) beanDefinitions.get(beanName);        if (definition == null) {            throw new RuntimeException("No bean named '" + beanName + "' available");        }        try {            // 3. 标记Bean为正在创建中            singletonRegistry.beforeSingletonCreation(beanName);            // 4. 创建Bean实例            T instance = createBean(definition);            // 5. 添加到三级缓存，用于解决循环依赖            singletonRegistry.addSingletonFactory(beanName, () -> instance);            // 6. 注入依赖            injectDependencies(instance, definition);            // 7. 初始化Bean            initializeBean(instance);            // 8. 注册到单例缓存（一级缓存）            singletonRegistry.registerSingleton(beanName, instance);            return instance;        } catch (Exception e) {            throw new RuntimeException("Error creating bean with name '" + beanName + "': " + e.getMessage(), e);        } finally {            // 9. 标记Bean创建完成            singletonRegistry.afterSingletonCreation(beanName);        }    }    // 其他辅助方法...    private <T> T createBean(BeanDefinition<T> definition) throws Exception {        System.out.println("Creating bean instance for: " + definition.getBeanClass().getSimpleName());        return definition.getBeanClass().getDeclaredConstructor().newInstance();    }    private <T> void injectDependencies(T instance, BeanDefinition<T> definition) throws Exception {        // 简化的依赖注入实现        // 实际Spring中会使用反射查找setter方法或字段    }    private <T> void initializeBean(T instance) {        System.out.println("Initializing bean: " + instance.getClass().getSimpleName());    }    /**     * Bean定义内部类     */    private static class BeanDefinition<T> {        private final Class<T> beanClass;        private final String[] dependencies;        public BeanDefinition(Class<T> beanClass, String[] dependencies) {            this.beanClass = beanClass;            this.dependencies = dependencies;        }        public Class<T> getBeanClass() {            return beanClass;        }        public String[] getDependencies() {            return dependencies;        }    }}

/** * 示例BeanA，与BeanB形成循环依赖 */public class BeanA {    private BeanB beanB;    publicBeanA() {        System.out.println("BeanA constructor called");    }    // Setter方法用于依赖注入    publicvoidsetBeanB(BeanB beanB) {        this.beanB = beanB;        System.out.println("BeanA injected with BeanB");    }    public String getMessage() {        return "Hello from BeanA";    }}/** * 示例BeanB，与BeanA形成循环依赖 */public class BeanB {    private BeanA beanA;    publicBeanB() {        System.out.println("BeanB constructor called");    }    // Setter方法用于依赖注入    publicvoidsetBeanA(BeanA beanA) {        this.beanA = beanA;        System.out.println("BeanB injected with BeanA");    }    public String getMessage() {        return "Hello from BeanB";    }}

┌─────────────┐     ┌─────────────┐     ┌─────────────┐│ 创建BeanA   │     │ 创建BeanB   │     │ 完成初始化 │└─────┬───────┘     └─────┬───────┘     └─────┬───────┘      │                   │                   │      ▼                   ▼                   ▼┌─────────────┐     ┌─────────────┐     ┌─────────────┐│ 1.标记创建中 │     │ 4.标记创建中 │     │ 12.BeanA完成│└─────┬───────┘     └─────┬───────┘     └─────┬───────┘      │                   │                   │      ▼                   ▼                   ▼┌─────────────┐     ┌─────────────┐     ┌─────────────┐│ 2.实例化BeanA│     │ 5.实例化BeanB│     │ 13.放入一级 │└─────┬───────┘     └─────┬───────┘     └─────┬───────┘      │                   │                   │      ▼                   ▼                   │┌─────────────┐     ┌─────────────┐           ││ 3.放入三级缓存│─────▶7.需要BeanA │           │└─────┬───────┘     └─────┬───────┘           │      │                   │                   │      ▼                   ▼                   │┌─────────────┐     ┌─────────────┐           ││ 9.从三级获取│◀────┼8.查找BeanA  │           │└─────┬───────┘     └─────┬───────┘           │      │                   │                   │      ▼                   ▼                   │┌─────────────┐     ┌─────────────┐           ││10.放入二级缓存│     │11.BeanB完成 │           │└─────┬───────┘     └─────┬───────┘           │      │                   │                   │      └───────────────────┘                   │                        │                     │                        ▼                     │                ┌─────────────┐               │                │  放入一级缓存 │               │                └─────────────┘               │                        │                     │                        └─────────────────────┘

// 创建自定义Bean工厂CustomBeanFactory beanFactory = new CustomBeanFactory();// 注册Bean定义，声明循环依赖关系beanFactory.registerBean("beanA", BeanA.class, "beanB");beanFactory.registerBean("beanB", BeanB.class, "beanA");// 获取BeanA，这将触发循环依赖的解决过程BeanA beanA = beanFactory.getBean("beanA");

Creating bean instance for: BeanABeanA constructor calledCreating bean instance for: BeanBBeanB constructor calledBeanB injected with BeanAInitializing bean: BeanBBeanA injected with BeanBInitializing bean: BeanA

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = SpringConfig.class)public class SpringThreeLevelCacheTest {    @Autowired    private ServiceA serviceA;    @Autowired    private ServiceB serviceB;    @Test    public void testCircularDependency() {        System.out.println("\n===== Spring三级缓存循环依赖测试 =====");        // 验证ServiceA是否成功注入了ServiceB        System.out.println("ServiceA调用结果: " + serviceA.getInfo());        // 验证循环依赖是否成功解决        System.out.println("验证循环依赖是否解决:");        System.out.println("- ServiceA的serviceB引用: " + serviceB.getMessage());        // 打印两个对象的hashCode，确认是同一个实例        System.out.println("\n对象引用验证:");        System.out.println("- ServiceA实例: " + serviceA);        System.out.println("- ServiceB实例: " + serviceB);        System.out.println("\nSpring三级缓存成功解决了循环依赖问题！");    }}

@Componentpublic class ServiceA {    private ServiceB serviceB;    publicServiceA() {        System.out.println("ServiceA构造函数被调用");    }    @Autowired    publicvoidsetServiceB(ServiceB serviceB) {        System.out.println("ServiceA的setServiceB方法被调用");        this.serviceB = serviceB;    }    public String getInfo() {        return "ServiceA调用ServiceB: " + serviceB.getMessage();    }}@Componentpublic class ServiceB {    private ServiceA serviceA;    publicServiceB() {        System.out.println("ServiceB构造函数被调用");    }    @Autowired    publicvoidsetServiceA(ServiceA serviceA) {        System.out.println("ServiceB的setServiceA方法被调用");        this.serviceA = serviceA;    }    public String getMessage() {        return "Hello from ServiceB";    }}

public class CustomThreeLevelCacheTest {    @Test    publicvoidtestCustomThreeLevelCache() {        System.out.println("\n===== 自定义三级缓存循环依赖测试 =====");        // 创建自定义Bean工厂        CustomBeanFactory beanFactory = new CustomBeanFactory();        // 注册Bean定义，声明循环依赖关系        beanFactory.registerBean("beanA", BeanA.class, "beanB");        beanFactory.registerBean("beanB", BeanB.class, "beanA");        System.out.println("\n开始获取BeanA（触发循环依赖解决过程）...");        // 获取BeanA，这将触发循环依赖的解决过程        BeanA beanA = beanFactory.getBean("beanA");        // 验证循环依赖解决结果...    }    @Test    publicvoidtestDetailedCacheProcess() {        // 详细测试三级缓存的工作流程...    }}

public class CustomSingletonBeanRegistry {    // 一级缓存：存储完全初始化好的单例Bean    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);    // 二级缓存：存储早期曝光的Bean实例    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);    // 三级缓存：存储Bean工厂对象    private final Map<String, CustomObjectFactory<?>> singletonFactories = new HashMap<>(16);    // 获取单例Bean的核心方法    public Object getSingleton(String beanName) {        // 1. 先从一级缓存获取        // 2. 如果不存在且Bean正在创建中，从二级缓存获取        // 3. 如果二级缓存也不存在，从三级缓存获取工厂对象        // 4. 通过工厂获取早期引用并升级到二级缓存    }    // 其他关键方法：registerSingleton, addSingletonFactory等}

public class CustomBeanFactory {    private final CustomSingletonBeanRegistry singletonRegistry = new CustomSingletonBeanRegistry();    public <T> T getBean(String beanName) {        // 1. 先尝试从缓存获取        // 2. 标记Bean为正在创建中        // 3. 创建Bean实例        // 4. 添加到三级缓存        // 5. 注入依赖        // 6. 初始化Bean        // 7. 注册到一级缓存    }}

ServiceA构造函数被调用ServiceB构造函数被调用ServiceB的setServiceA方法被调用ServiceA的setServiceB方法被调用===== Spring三级缓存循环依赖测试 =====ServiceA调用结果: ServiceA调用ServiceB: Hello from ServiceB验证循环依赖是否解决:- ServiceA的serviceB引用: Hello from ServiceB对象引用验证:- ServiceA实例: com.example.cache.ServiceA@1a2b3c4d- ServiceB实例: com.example.cache.ServiceB@5e6f7g8h

BeanA constructor calledBeanB constructor calledBeanB injected with BeanABeanA injected with BeanB===== 自定义三级缓存循环依赖测试 =====BeanA的消息: Hello from BeanA, using injected BeanBBeanB的消息: Hello from BeanB, using injected BeanA验证循环引用的一致性:- beanA.getBeanB() == beanB: true- beanB.getBeanA() == beanA: true