Spring-循环依赖之三级缓存

最新推荐文章于 2025-10-17 11:05:49 发布

原创最新推荐文章于 2025-10-17 11:05:49 发布 · 384 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#spring

Spring 专栏收录该内容

2 篇文章

订阅专栏

本文深入探讨Spring框架中如何通过三级缓存机制解决singleton注入的循环依赖问题，剖析构造器注入和prototype注入为何无法利用此机制。

三级缓存处理循环依赖

为什么会存在循环依赖的问题呢？

假如现在有两个类，A和B，A里面引用了B，B里面引用了A，A初始化的时候会注入B，B还没有创建，就马上开始创建B的过程，在创建B时，又需要注入A，而A还没有创建完成，就形成了循环依赖，也就是循环引用。

Spring循环依赖有三种情况：

构造器注入
singleton注入（setter注入单例，spring注入的默认方式）
prototype注入（setter注入原型）

注意，循环依赖只能解决singleton注入形成的循环依赖

三级缓存：

//一级缓存，所有初始化好的Bean（可以直接使用）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
//二级缓存，根据名称可知，用于存放提前曝光的单例对象的map，实例化还没有填充属性，
private final Map<String, Object> earlySingletonObjects = new HashMap(16);
//三级缓存，单例对象工厂
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);

//正在创建中的单例对象的名称集合，创建完成会被移除
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16));
//创建成功的单例对象的名称集合
private final Set<String> registeredSingletons = new LinkedHashSet(256);

singleton注入利用三级缓存解决循环依赖

借助网图给大家展示下创建A和B的过程在这里插入图片描述

实例化A（正常实例化）到第十步的时候发现依赖了B，然后在第九步执行了addSingletonFactory（）方法

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	...
    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放到了singletonFactories集合里面，执行到这里

//一级缓存
singletonObjects//没有A
//二级缓存
earlySingletonObjects//没有A
//三级缓存
singletonFactories//有A
//正在创建中的单例对象的名称集合
singletonsCurrentlyInCreation//有A
//创建成功的单例对象的名称集合
registeredSingletons//有A

然后执行第十步，发现没有B的实例，就开始创建B，到第十步之前也都是正常流程，

到第十步，当执行到autowireByName（）方法时要调用getBean（）方法去容器里面找A

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    ...
    protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
        String[] propertyNames = this.unsatisfiedNonSimpleProperties(mbd, bw);
        String[] var6 = propertyNames;
        int var7 = propertyNames.length;

        for(int var8 = 0; var8 < var7; ++var8) {
            String propertyName = var6[var8];
            if (this.containsBean(propertyName)) {
                Object bean = this.getBean(propertyName);//调用getBean()
                pvs.add(propertyName, bean);
                this.registerDependentBean(propertyName, beanName);
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Added autowiring by name from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
                }
            } else if (this.logger.isTraceEnabled()) {
                this.logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName + "' by name: no matching bean found");
            }
        }
    }
    ...
}

而最终getBean（）方法调用getSingleton（）方法，这里是重点

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);//一级缓存里面找
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            synchronized(this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);//二级缓存里面找
                if (singletonObject == null && allowEarlyReference) {
                    //三级缓存里面找
                    ObjectFactory<?> singletonFactory =(ObjectFactory)this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        //将三级缓存里面的剪切到二级缓存里面
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }

        return singletonObject;
    }
}