【无标题】

最新推荐文章于 2025-04-25 17:16:24 发布

HLhakey

最新推荐文章于 2025-04-25 17:16:24 发布

阅读量231

点赞数 3

文章标签： spring java 后端循环依赖

本文链接：https://blog.youkuaiyun.com/HLhakey/article/details/146132854

版权

Spring 循环依赖解决方案完全指南

一、什么是循环依赖

循环依赖指的是两个或多个 Bean 之间相互依赖，形成了一个闭环。例如：

A 依赖 B，B 依赖 A
A 依赖 B，B 依赖 C，C 依赖 A

二、Spring 解决方案的核心要素

1. 三级缓存

// 一级缓存：存储完全初始化的 bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 二级缓存：存储早期的 bean 引用
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

// 三级缓存：存储 bean 的工厂对象
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

2. 创建中标记集合

// 记录正在创建中的 bean
private final Set<String> singletonsCurrentlyInCreation = 
    Collections.newSetFromMap(new ConcurrentHashMap<>(16));

三、解决循环依赖的完整流程

1. Bean 创建开始

protected void beforeSingletonCreation(String beanName) {
    // 将 bean 加入创建中标记集合
    if (!this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

2. 实例化 Bean

创建空对象（仅调用构造方法）
将对象工厂放入三级缓存

3. 属性注入时发现循环依赖

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 先查一级缓存
    Object singletonObject = this.singletonObjects.get(beanName);
    
    // 如果一级缓存没有，且当前 bean 正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 查二级缓存
        singletonObject = this.earlySingletonObjects.get(beanName);
        
        // 如果二级缓存也没有，尝试三级缓存
        if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> factory = this.singletonFactories.get(beanName);
            if (factory != null) {
                // 从三级缓存获取早期引用
                singletonObject = factory.getObject();
                // 放入二级缓存
                this.earlySingletonObjects.put(beanName, singletonObject);
                // 从三级缓存移除
                this.singletonFactories.remove(beanName);
            }
        }
    }
    return singletonObject;
}

四、循环依赖的判定过程

1. 标记判定

通过 singletonsCurrentlyInCreation 集合判断 Bean 是否在创建中
当发现要获取的 Bean 在创建中时，说明可能存在循环依赖

2. 处理流程

A 创建时，将 A 加入 singletonsCurrentlyInCreation
A 注入属性时发现依赖 B，开始创建 B
B 创建时，将 B 加入 singletonsCurrentlyInCreation
B 注入属性时发现依赖 A
发现 A 在 singletonsCurrentlyInCreation 中，确认存在循环依赖
尝试从三级缓存获取 A 的早期引用

五、缓存的移除时机

1. Bean 完全初始化后

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 放入一级缓存
        this.singletonObjects.put(beanName, singletonObject);
        // 从三级缓存移除
        this.singletonFactories.remove(beanName);
        // 从二级缓存移除
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

2. Bean 创建失败时

protected void removeSingleton(String beanName) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.remove(beanName);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.remove(beanName);
    }
}