原来Spring是这样解决循环依赖的

最新推荐文章于 2024-10-10 11:29:57 发布

原创最新推荐文章于 2024-10-10 11:29:57 发布 · 8.1k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#rabbitmq #java #数据库

Spring/Spring Boot 专栏收录该内容

26 篇文章

订阅专栏

本文深入探讨Spring框架如何处理和解决循环依赖问题，特别是在单例Bean的场景下，通过三级缓存机制确保应用程序的稳定性和效率。

什么是循环依赖

通常来说，Spring循环依赖的场景一般是单例Bean。

几个Bean之间的循环依赖

@Component
public class A {

    @Autowired
    private B b;
}

@Component
public class B {

    @Autowired
    private C c;
}

@Component
public class C {

    @Autowired
    private A a;
}

效果图如下：
在这里插入图片描述

自己依赖自己

@Component
public class A {

    @Autowired
    private A a;
}

效果图如下：
在这里插入图片描述
先说明前提：原型(Prototype)的场景是不支持循环依赖的，通常会走到AbstractBeanFactory类中下面的判断，抛出异常。

当创建A的时候，发现要注入原型字段B，又创建新的B发现要注入原型字段A，这个时候就会抛出BeanCurrentlyInCreationException异常。

if (isPrototypeCurrentlyInCreation(beanName)) {
  throw new BeanCurrentlyInCreationException(beanName);
}

举个栗子

<bean id="beanA" class="xxx.xxx.BeanA">
    <property name="beanB" ref="beanB"/>
</bean>
<bean id="beanB" class="xxx.xxx.BeanB">
    <property name="beanA" ref="beanA"/>
</bean>

IOC 容器在读到上面的配置时，会按照顺序，先去实例化 beanA。然后发现 beanA 依赖于 beanB，接在又去实例化 beanB。实例化 beanB 时，发现 beanB 又依赖于 beanA。如果容器不处理循环依赖的话，容器会无限执行上面的流程，直到内存溢出，程序崩溃。

当然，Spring 是不会让这种情况发生的。在容器再次发现 beanB 依赖于 beanA 时，容器会获取 beanA 对象的一个早期的引用（early reference），并把这个早期引用注入到 beanB 中，让 beanB 先完成实例化。beanB 完成实例化，beanA 就可以获取到 beanB 的引用，beanA 随之完成实例化。

Spring是如何解决循环依赖的

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	/** Cache of singleton objects: bean name to bean instance. */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name to ObjectFactory. */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name to bean instance. */
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

	// 。。。
}

首先Spring维护了三个Map，也就是我们通常说的三级缓存。