当前位置：首页 > news >正文

Spring循环依赖问题，Spring是如何解决循环依赖的？

news 2026/2/7 22:00:11

文章目录

一、什么是循环依赖
- 1、代码实例
- 2、重要信息
二、源码分析
- 1、初始化Student
- - 对Student中的ClassRoom进行Autowire操作
- 2、Student的自动注入ClassRoom时，又对ClassRoom的初始化
- 3、ClassRoom的初始化，又执行自动注入Student的逻辑
- 4、Student注入ClassRoom
- 5、初始化完成的Bean放入一级缓存
三、总结
- 1、二级缓存的用处
- 2、汇总流程图！
参考资料

一、什么是循环依赖

多个bean之间相互依赖，形成了一个闭环。比如:A依赖于B、B依赖于C、C依赖于A。
在这里插入图片描述
注意，这里不是函数的循环调用，是对象的相互依赖关系。循环调用其实就是一个死循环，除非有终结条件。

1、代码实例

public class ClassRoom {private String name;@Autowiredprivate Collection<Student> students;// get set
}public class Student {private Long id;private String name;@Autowiredprivate ClassRoom classRoom;// get set
}

public class CircularReferencesDemo {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 注册 Configuration Classcontext.register(CircularReferencesDemo.class);// 如果设置为 false，则抛出异常信息如：currently in creation: Is there an unresolvable circular reference?// 默认值为 truecontext.setAllowCircularReferences(true);// 启动 Spring 应用上下文context.refresh();System.out.println("Student : " + context.getBean(Student.class));System.out.println("ClassRoom : " + context.getBean(ClassRoom.class));// 关闭 Spring 应用上下文context.close();}@Beanpublic static Student student() {Student student = new Student();student.setId(1L);student.setName("张三");return student;}@Beanpublic static ClassRoom classRoom() {ClassRoom classRoom = new ClassRoom();classRoom.setName("C122");return classRoom;}
}

我们看到以上实例ClassRoom和Student是互相依赖的。

Spring默认是打开处理循环依赖的开关的，我们可以使用setAllowCircularReferences方法手动设置关闭循环依赖。

开启解决循环依赖之后，以上代码是可以执行没有问题的。关闭循环依赖，以上就会出现循环依赖的异常，如果确认项目中没有循环依赖的问题可以关闭，以提高性能。

2、重要信息

本文的源码都是基于Spring5.2.2版本进行分析的，其他版本或许有些许出入，但是差别不大。

本文所说的循环引用，都是指的是单例Bean，原型Bean不在此分析中。

阅读本文需要明白一些前置知识点：
（1）单例的Bean初始化时机-finishBeanFactoryInitialization方法执行时：
Spring应用上下文生命周期详解及源码分析，Spring IOC容器启动及关闭过程超详细解释（上）
（2）Bean的生命周期需要熟悉：
Spring Bean生命周期——从源码角度详解Spring Bean的生命周期（上）
Spring Bean生命周期——从源码角度详解Spring Bean的生命周期（下）
（3）@Autowire注入流程
@Autowire源码分析，@Autowire是怎么实现依赖注入的

二、源码分析

我们先从IOC容器启动时执行的finishBeanFactoryInitialization方法开始入口，此方法是单例Bean的创建入口，然后执行preInstantiateSingletons方法正是开始创建单例Bean。

// org.springframework.context.support.AbstractApplicationContext#refresh
@Override
public void refresh() throws BeansException, IllegalStateException {// 省略上面代码// Instantiate all remaining (non-lazy-init) singletons.// 关键方法！完成BeanFactory的初始化finishBeanFactoryInitialization(beanFactory); // 省略下面代码

// org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// 省略上面代码// Instantiate all remaining (non-lazy-init) singletons.// 关键方法！初始化单例的BeanbeanFactory.preInstantiateSingletons();
}

preInstantiateSingletons方法在DefaultListableBeanFactory中进行了实现。

// org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
@Override
public void preInstantiateSingletons() throws BeansException {// Trigger initialization of all non-lazy singleton beans...for (String beanName : beanNames) {RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {if (isFactoryBean(beanName)) {Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);if (bean instanceof FactoryBean) {final FactoryBean<?> factory = (FactoryBean<?>) bean;boolean isEagerInit;if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext());}else {isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {getBean(beanName);}}}else { // 关键方法！获取Bean的入口getBean(beanName);}}}// 省略下面代码

1、初始化Student

第一个首先是初始化我们的Student类，getBean会调用doGetBean，然后调用getSingleton方法（重点！解决循环依赖最重要的三级缓存）：

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName); // 一级缓存if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName); // 二级缓存if (singletonObject == null && allowEarlyReference) {ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); // 三级缓存if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;
}

第一次调用getSingleton方法不会获取到Bean，获取的是null，走下面的单例bean创建逻辑：

// org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean// 省略上面代码
// Create bean instance.
if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args); // 关键方法！创建Bean，开始正式进入Bena的生命周期}catch (BeansException ex) {// Explicitly remove instance from singleton cache: It might have been put there// eagerly by the creation process, to allow for circular reference resolution.// Also remove any beans that received a temporary reference to the bean.destroySingleton(beanName);throw ex;}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}// 省略下面代码

createBean方法会调用doCreateBean方法，doCreateBean方法会创建bean的实例，然后完成属性的初始化（@Autowire还未开始），然后会判断如果该Bean正在创建，就会调用addSingletonFactory方法：

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean// 省略上面创建bean的实例，然后完成属性的初始化（@Autowire还未开始）的代码
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}// 省略下面@Autowire的代码

我们会发现，此处对allowCircularReferences 进行了判断，假如说我们打开了循环依赖的开关，会走这个逻辑。

addSingletonFactory方法，通过传入的单例对象工厂，

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory
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列表}}
}

我们注意到此时Student中的classRoom并没有被注入，但是id和name属性已经被初始化了。
在这里插入图片描述

对Student中的ClassRoom进行Autowire操作

我们回到doCreateBean方法，接下来会执行populateBean初始化属性值，会调用@Autowire的处理类AutowiredAnnotationBeanPostProcessor的postProcessProperties方法进行处理@Autowire注入。

// populateBean方法，此处省略部分代码PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {if (pvs == null) {pvs = mbd.getPropertyValues();}for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;// 关键方法！最终调用AutowiredAnnotationBeanPostProcessor的postProcessPropertiesPropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {return;}}pvs = pvsToUse;}}
}

// org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessProperties
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs); // 关键方法}catch (BeanCreationException ex) {throw ex;}catch (Throwable ex) {throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);}return pvs;
}

// org.springframework.beans.factory.annotation.InjectionMetadata#inject
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {Collection<InjectedElement> checkedElements = this.checkedElements;Collection<InjectedElement> elementsToIterate =(checkedElements != null ? checkedElements : this.injectedElements);if (!elementsToIterate.isEmpty()) {for (InjectedElement element : elementsToIterate) {if (logger.isTraceEnabled()) {logger.trace("Processing injected element of bean '" + beanName + "': " + element);}element.inject(target, beanName, pvs); // 关键方法}}
}

inject方法此处需要自动注入的是属性，需要获取该属性的value值也就是ClassRoom（此时ClassRoom尚未初始化）。

// org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
// 此处省略部分源码
try {// value就是需要获取的ClassRoomvalue = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}

// org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());if (Optional.class == descriptor.getDependencyType()) {return createOptionalDependency(descriptor, requestingBeanName);}else if (ObjectFactory.class == descriptor.getDependencyType() ||ObjectProvider.class == descriptor.getDependencyType()) {return new DependencyObjectProvider(descriptor, requestingBeanName);}else if (javaxInjectProviderClass == descriptor.getDependencyType()) {return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);}else {Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);if (result == null) {// 关键代码！会走该逻辑result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);}return result;}
}

// doResolveDependency方法，省略部分源码，会调用resolveCandidate
if (instanceCandidate instanceof Class) {instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}

resolveCandidate会执行beanFactory.getBean方法，又开始了对ClassRoom的getBean操作，开始处理ClassRoom。

// 
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)throws BeansException {return beanFactory.getBean(beanName);
}

2、Student的自动注入ClassRoom时，又对ClassRoom的初始化

我们跳过上面的分析，来到addSingletonFactory方法：
在这里插入图片描述
我们发现，又将ClassRoom放入了三级缓存，此时三级缓存中有了Student和ClassRoom，但是都没有完成对ClassRoom和Student的自动注入工作。

3、ClassRoom的初始化，又执行自动注入Student的逻辑

此时，我们来到ClassRoom的populateBean属性初始化方法，仍然调用AutowiredAnnotationBeanPostProcessor的postProcessProperties方法，来完成对Student的自动注入。

省略我们分析Student的自动注入步骤，我们继续分析，自动注入的过程仍然会调用resolveDependency方法，然后调用doResolveDependency方法，然后调用resolveCandidate方法，又通过beanFactory.getBean来获取Student。

还记得我们上面分析的，doGetBean方法中调用的getSingleton方法的逻辑，此时从三级缓存中已经能够获取到Student了，但是该Student的ClassRoom仍然是null的，但是能够获取到Studen实例，并不影响我们ClassRoom对Student的注入！

// org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {final String beanName = transformedBeanName(name);Object bean;// Eagerly check singleton cache for manually registered singletons.// 关键方法！Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {if (logger.isTraceEnabled()) {if (isSingletonCurrentlyInCreation(beanName)) {logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else {logger.trace("Returning cached instance of singleton bean '" + beanName + "'");}}bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);}

从三级缓存中获取到Student后，将Student从三级缓存移出，放入二级缓存。
在这里插入图片描述

此时，在ClassRoom的初始化自动注入Student的过程，获取到了我们的Student（还未注入CLassRoom），在Inject方法中，继续执行会发现通过反射，将Student写入了ClassRoom的属性。

// org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {Field field = (Field) this.member;Object value;if (this.cached) {value = resolvedCachedArgument(beanName, this.cachedFieldValue);}else {DependencyDescriptor desc = new DependencyDescriptor(field, this.required);desc.setContainingClass(bean.getClass());Set<String> autowiredBeanNames = new LinkedHashSet<>(1);Assert.state(beanFactory != null, "No BeanFactory available");TypeConverter typeConverter = beanFactory.getTypeConverter();try {value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);}catch (BeansException ex) {throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);}synchronized (this) {if (!this.cached) {if (value != null || this.required) {this.cachedFieldValue = desc;registerDependentBeans(beanName, autowiredBeanNames);if (autowiredBeanNames.size() == 1) {String autowiredBeanName = autowiredBeanNames.iterator().next();if (beanFactory.containsBean(autowiredBeanName) &&beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {this.cachedFieldValue = new ShortcutDependencyDescriptor(desc, autowiredBeanName, field.getType());}}}else {this.cachedFieldValue = null;}this.cached = true;}}}if (value != null) {ReflectionUtils.makeAccessible(field);field.set(bean, value); // 通过反射写入属性}
}

此时完成了ClassRoom的初始化。

4、Student注入ClassRoom

此时ClassRoom在Student初始化过程，完成了初始化并注入Student实例，此时的Student还没有完成对ClassRoom的注入呢！

我们又回到Student的inject方法了（此时相当于是一个递归的过程）。

对ClassRoom的create的过程，会返回创建好的ClassRoom实例（初始化完成也注入完成），正好将ClassRoom注入到Student中。

此时完成对Student和ClassRoom的初始化过程。

也正式解决了Student和ClassRoom的循环依赖问题。

5、初始化完成的Bean放入一级缓存

我们再次回到doGetBean方法，这里调用了getSingleton方法，getSingleton方法最后面的finally中会调用addSingleton方法。

// Create bean instance.
if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);}catch (BeansException ex) {// Explicitly remove instance from singleton cache: It might have been put there// eagerly by the creation process, to allow for circular reference resolution.// Also remove any beans that received a temporary reference to the bean.destroySingleton(beanName);throw ex;}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

addSingleton方法会将Bean放入一级缓存，同时删除二级缓存和三级缓存中的Bean，此时Bean初始化完成，同时也缓存完成，下次获取Bean直接从一级缓存获取即可，提高性能。

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton
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);}
}

关于Bean的缓存请移步：
Spring中Bean会被缓存吗？Spring的Bean是如何被缓存的？

三、总结

Spring解决循环依赖，正式靠着这三级缓存完成的，相当于一个递归初始化的过程：
在这里插入图片描述

在 Spring 底层 IoC 容器 BeanFactory 中处理循环依赖的方法主要借助于以下 3 个 Map 集合：

singletonObjects（一级 Map），里面保存了所有已经初始化好的单例 Bean
earlySingletonObjects（二级 Map），里面会保存从 三级 Map 获取到的正在初始化的 Bean，保存的同时会移除 三级 Map 中对应的 ObjectFactory 实现类，在完全初始化好某个 Bean 时会移除 二级 Map中对应的早期对象
singletonFactories（三级 Map），里面保存了正在初始化的 Bean 对应的 ObjectFactory 实现类，调用其 getObject() 方法返回正在初始化的 Bean 对象（仅实例化还没完全初始化好）

而这三个缓存，其实也就是人们称的三级缓存，其实严格意义上并不能称为“缓存”，这三个缓存其实都是Map：
在这里插入图片描述

1、二级缓存的用处

此处解决循环依赖似乎并没有用到二级缓存，那么二级缓存是哪里用到的呢？

因为通过 三级 Map获取 Bean 会有相关 SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference 的处理，避免重复处理。
例如在循环依赖中一个 Bean 可能被多个 Bean 依赖， A -> B（也依赖 A） -> C -> A，当你获取 A 这个 Bean 时，后续 B 和 C 都要注入 A，没有上面的 二级 Map的话，三级 Map 保存的 ObjectFactory 实现类会被调用两次，会重复处理，可能出现问题。这就是为什么需要 3 个 Map，另外这样做在性能上也有所提升。

也是为了处理AOP动态代理的问题，也是一个对象被多个对象重复依赖，导致重复创建的问题：
假如 A 需要进行 AOP，因为代理对象每次都是生成不同的对象，如果干掉第二级缓存，只有第一、三级缓存：
B 找到 A 时，直接通过三级缓存的工厂的代理对象，生成对象 A1。
C 找到 A 时，直接通过三级缓存的工厂的代理对象，生成对象 A2。
看到问题没？你通过 A 的工厂的代理对象，生成了两个不同的对象 A1 和 A2，所以为了避免这种问题的出现，我们搞个二级缓存，把 A1 存下来，下次再获取时，直接从二级缓存获取，无需再生成新的代理对象。

2、汇总流程图！

在这里插入图片描述

参考资料

spring如何解决循环依赖
源码深度解析，Spring 如何解决循环依赖？
极客时间《小马哥讲 Spring 核心编程思想》