欢迎来到啾啾的博客🐱，一个致力于构建完善的Java程序员知识体系的博客📚，记录学习的点滴，分享工作的思考、实用的技巧，偶尔分享一些杂谈💬。
欢迎评论交流，感谢您的阅读😄。

本篇总结了Spring单例Bean循环依赖的解决机制——“三级缓存”，其本质是创建过程依赖的解耦，提前暴露对象引用，利用多级缓存机制存储引用与实例对象。

需要先理解SpringBean的生命周期，不理解也没关系，看一下doCreateBean方法也就记住了。

⬅️前文

设计模式概览

目录

单例模式-Spring DefaultSingletonBeanRegistry

三级缓存解决单例Bean循环依赖

三级缓存机制

循环依赖具体解决步骤

循环依赖限制

单例Bean限制

构造器注入限制

单例模式-Spring DefaultSingletonBeanRegistry

单例模式定义为“确保一个类只有一个实例，并提供一个全局访问点来访问这个实例”。

Spring默认的Bean作用域就是单例的，每个Bean在Spring容器中只有一个实例。

Spring框架DefaultSingletonBeanRegistry类，使用CouncurrentHashMap存储单例对象，并提供getSingleton方法获取对象。

DefaultSingletonBeanRegistry中的单例模式代码提取如下：

public class DefaultSingletonBeanRegistry {private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);public Object getSingleton(String beanName) {return singletonObjects.get(beanName);}
}

值得注意的是，一级缓存初始化时指定了256的初始容量，在Java基础-集合篇中有提到这是一种常见的提升性能的写法。

同时，这段代码也可以用于解释Spring是如何通过三级缓存机制来解决单例Bean的依赖循环问题。

三级缓存解决单例Bean循环依赖

以 Bean A → 依赖 Bean B → 依赖 Bean A 的循环依赖场景为例。

总所周知，Bean的生命周期为实例化、属性注入、初始化、使用、销毁。

在BeanA实例化后进行属性注入操作创建属性BeanB时，发现BeanB属性注入操作需要创建BeanA，此时便形成了循环依赖。

Spring通过三级缓存机制来解决循环依赖。

三级缓存机制

核心机制是二级缓存的对象早期引用Early Bean Reference，相当于在对象完成初始化前体现暴露对象引用。

辅助理解：类似面向接口编程思想，体现暴露对象引用相当于提供接口，创建Bean不管具体实现，实现创建过程的解耦，进而解决循环依赖问题。

循环依赖具体解决步骤

1.Bean A实例化后
        将ObjectFactory存入三级缓存（此时A尚未完成属性注入）
        触发populateBean()时发现需要注入Bean B
2.创建Bean B
        实例化Bean B后同样存入三级缓存
        触发populateBean()时发现需要注入Bean A
3.获取Bean A的早期引用
        通过getSingleton("A")从三级缓存获取ObjectFactory
        通过工程对象调用getEarlyBeanReference()获取未完成初始化的BeanA对象，即BeanA的早期引用（Early Bean Reference）
4.完成Bean B的初始化
        Bean B获得A的代理对象后完成初始化
        Bean B被存入一级缓存
5.继续完成Bean A的初始化
        将Bean B注入到Bean A
        Bean A完成初始化后存入一级缓存
        清除二级缓存中的A对象

结合AbstractAutowireCapableBeanFactory源码分析，创建Bean时，实例化后将工程对象存入三级缓存，用于后续创建对象早期引用。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {// 1. 实例化Bean A（此时对象未初始化）Object bean = instanceWrapper.getWrappedInstance();// 2. 将Bean A的工厂对象存入三级缓存（关键步骤！）addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));// 3. 属性注入（触发Bean B的创建）populateBean(beanName, mbd, instanceWrapper);// 4. 初始化（调用InitializingBean等）exposedObject = initializeBean(beanName, exposedObject, mbd);return exposedObject;
}

核心方法⬇️

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");synchronized (this.singletonObjects) {if (!this.singletonObjects.containsKey(beanName)) {// 存入三级缓存this.singletonFactories.put(beanName, singletonFactory);// 确保二级缓存中没有残留this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}
}

获取Bean的源码提取如下⬇️：

public class DefaultSingletonBeanRegistry {// 一级缓存：存放完全初始化的Bean（成品对象）private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();// 二级缓存：存放早期暴露的Bean（半成品对象，未完成属性注入）private final Map<String, Object> earlySingletonObjects = new HashMap<>();// 三级缓存：存放Bean工厂对象（用于生成半成品对象）private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();protected Object getSingleton(String beanName, boolean allowEarlyReference) {// 1. 从一级缓存查询Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {// 2. 从二级缓存查询singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {// 3. 从三级缓存获取工厂对象ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {// 生成早期引用（可能被AOP代理）singletonObject = singletonFactory.getObject();// 升级到二级缓存this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;}
}

补充源码图如下：

循环依赖限制

三级缓存机制仅能解决单例Bean且非构造器注入的循环依赖。

单例Bean限制

原型（Prototype）作用域的Bean每次请求都会创建新实例，即提前暴露引用也没用，引用会发生变化，无法通过缓存保存中间状态，因此无法解决循环依赖。

创建bean的源码AbstractAutowireCapableBeanFactory.doCreateBean中也做了bean是否是singleton的判断

构造器注入限制

构造器注入无法解决循环依赖。构造器注入要求在实例化Bean时立即注入依赖，而Spring需要实例化完成后才能提前暴露对象引用。构造器循环依赖时，Bean尚未实例化，无法提前暴露引用，导致死锁。

@Service
public class A {private final B b;@Autowired // 构造器注入B,创建B需要注入Apublic A(B b) {this.b = b;}
}@Service
public class B {private final A a;@Autowiredpublic B(A a) { // 构造器注入A,创建A需要注入Bthis.a = a;}
}