一、复现循环依赖问题

Spring 中默认允许循环依赖的存在，但在 Spring Boot 2.6.x 版本开始默认禁用了循环依赖

1. 基于xml复现循环依赖

定义实体 Bean

java复制代码public class A {

private B b;

public B getB() { return b; }

public void setB(B b) { this.b = b; } }

java复制代码public class B {

private A a;

public A getA() { return a; }

public void setA(A a) { this.a = a; } }
重写 customizeBeanFactory 方法，禁止循环依赖

java复制代码public class NotAllowCircularXmlApplicationContext extends ClassPathXmlApplicationContext {

public NotAllowCircularXmlApplicationContext(String... configLocations) throws BeansException { super(configLocations); }

@Override protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) { // 禁止循环依赖 super.setAllowCircularReferences(false); super.customizeBeanFactory(beanFactory); } }
配置 xml 文件

xml复制代码

<context:component-scan base-package="com.sff.demo.cycle"/>
```
<bean id="b" class="com.sff.demo.cycle.B">
  <property name="a" ref="a"/>
```
java复制代码public class TestAnnoMain {

public static void main(String[] args) { testCycleRef(); }

public static void testXmlCycleRef() { NotAllowCircularXmlApplicationContext ac = new NotAllowCircularXmlApplicationContext("application-cycle.xml"); A bean = ac.getBean(A.class); System.out.println(bean); } }

运行结果：

2. 基于注解 @Autowired 复现循环依赖

实体定义

java复制代码@Component public class C {

@Autowired private D d; }

@Component public class D {

@Autowired private C c; }
重写 AnnotationConfigApplicationContext，禁止循环依赖

java复制代码public class NotAllowCircularAnnotationConfigApplicationContext extends AnnotationConfigApplicationContext {

public NotAllowCircularAnnotationConfigApplicationContext(Class<?>... annotatedClasses) { super(); register(annotatedClasses);
```
  // 禁止循环依赖
  super.setAllowCircularReferences(false);

  refresh();
```
} }
运行结果

java复制代码public class TestAnnoMain {

public static void main(String[] args) { testCycleRef(); }

public static void testCycleRef() { NotAllowCircularAnnotationConfigApplicationContext ac = new NotAllowCircularAnnotationConfigApplicationContext(BeanConfig3.class); C bean = ac.getBean(C.class); System.out.println(bean); } }

二、在 Spring 中是如何解决该问题的呢？

Spring 中利用三级缓存解决循环依赖问题，缓存定义在
DefaultSingletonBeanRegistry 中

java复制代码public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    // 一级缓存，保存 beanName 和 实例化、初始化好的完整 bean 对象
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    // 二级缓存，保存 beanName 和 未初始化的 bean 对象
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);  

    // 三级缓存，保存 beanName 和 lambda 表达式 () -> getEarlyBeanReference(beanName, mbd, bean)
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

}

Spring 中利用三级缓存解决循环依赖的根本就是为了避免引用对象的循环创建，那么它是如何实现这一目的呢？

在本文案例中 class A 中引用 class B ，同时在 class B 中引用 class A，在创建 A 对象时通过 addSingletonFactory方法，

java复制代码addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

在三级缓 singletonFactories.put(beanName,() -> getEarlyBeanReference(beanName, mbd, bean)) 中存放了 A 对象的这样一个 lambda 表达式，可以理解成回调函数。

当在创建 B 对象时，会调用通过 getSingleton 方法调用A对象三级缓存中的 lambda 表达式，也就是getEarlyBeanReference(beanName, mbd, bean) ，在没有AOP代理的情况下，可以直接返回 A 的对象信息，也就 getEarlyBeanReference(beanName, mbd, bean) 的参数 bean 就是提前缓存的 A 对象。

总结：

在 Spring 中，对象的创建分为实例化和初始化，实例化好但是未完成初始化的对象可以直接给其他对象引用，所以 Spring 中就把实例化好为初始化好的对象提前暴露出去，让其他对象能够进行引用，就完成了循环依赖的解耦！

作者：大飞学习笔记
链接：
juejin.cn/post/726126…

Spring源码之 Bean 的循环依赖

一、复现循环依赖问题

1. 基于xml复现循环依赖

2. 基于注解 @Autowired 复现循环依赖

二、在 Spring 中是如何解决该问题的呢？