【Spring】循环依赖

目录标题

什么是循环依赖
循环依赖场景
Java SE 演示
Spring 容器演示
三级缓存
- 核心知识
- - 三级缓存
  - 四大方法
  - 三级缓存中的迁移
- 三级缓存源码分析
- 源码思维导图
源码图例
课前问题
推荐阅读

循环依赖是什么？
循环依赖的场景有哪一些？
三级缓存分别是什么？三个Map有什么异同？
三级缓存是如何解决循环依赖的？
为什么要使用三级缓存？为什么不可以用二级缓存？
为什么构造器循环依赖、原型Bean循环依赖无法用三级缓存解决？
看过 Spring源码吗？一般我们说的 Spring容器是什么？
如何检测是否存在循环依赖？实际开发中见过循环依赖的异常吗？
如果循环依赖的时候，所有类又都需要 Spring AOP自动代理，那Spring如何提前曝光？曝光的是原始bean 还是代理后的bean ？

https://docs.spring.io/spring-framework/reference/

什么是循环依赖

多个Bean互相引用，形成环路

循环依赖场景

原型Bean的循环依赖
单例bean之构造注入的循环依赖
单例bean之setter注入的循环依赖

前两者无法解决，最后一种可以通过Spring提供的三级缓存来进行实现。

Java SE 演示

@Component
public class ServiceA {private ServiceB serviceB;public void setServiceB(ServiceB serviceB) {this.serviceB = serviceB;System.out.println("A 里面设置了B");}// public ServiceA(ServiceB serviceB) {//     this.serviceB = serviceB;// }
}

@Component
public class ServiceB {private ServiceA serviceA;public void setServiceA(ServiceA serviceA) {this.serviceA = serviceA;System.out.println("B 里面设置了A");}// public ServiceB(ServiceA serviceA) {//     this.serviceA = serviceA;// }
}

public class ClientDemo {public static void main(String[] args) {clientSet();// clientConstruct();}/*** setter注入*/private static void clientSet() {//创建serviceAServiceA serviceA = new ServiceA();//创建serviceBServiceB serviceB = new ServiceB();//将serviceA注入到serviceB中serviceB.setServiceA(serviceA);//将serviceB注入到serviceA中serviceA.setServiceB(serviceB);}/*** 构造注入*/private static void clientConstruct(){// new ServiceA(new ServiceB(new ServiceA(new ServiceB())));}
}

Spring 容器演示

<!--    <bean id="a" class="com.example.demo.circulardependency.spring.A" scope="singleton">--><bean id="a" class="com.example.demo.circulardependency.spring.A" scope="prototype"><property name="b" ref="b"/></bean><!--    <bean id="b" class="com.example.demo.circulardependency.spring.B" scope="singleton">--><bean id="b" class="com.example.demo.circulardependency.spring.B" scope="prototype"><property name="a" ref="a"/></bean>

public class ClientSpringContainer {public static void main(String[] args) {sampleDemo();}/*** spring** 2024/2/2 11:40*/private static void sampleDemo() {/*** setter注入* * 11:39:14.055 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Creating shared instance of singleton bean 'a'* ---A created success* 11:39:14.064 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Creating shared instance of singleton bean 'b'* ---B created success*//*** 构造注入* * Exception in thread "main" org.springframework.beans.factory.BeanCreationException:**/ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");A a = context.getBean("a", A.class);B b = context.getBean("b", B.class);}
}

三级缓存

Spring循环依赖 - CSDN博客

核心知识

三级缓存

一级缓存：Map<String, Object> singletonObjects，我愿称之为成品单例池，常说的 Spring 容器就是指它，我们获取单例 bean 就是在这里面获取的，存放已经经历了完整生命周期的Bean对象
二级缓存：Map<String, Object> earlySingletonObjects，存放早期暴露出来的Bean对象，Bean的生命周期未结束（属性还未填充完整，可以认为是 半成品的 bean, 实例化但未初始化的Bean对象）
三级缓存：Map<String, ObiectFactory<?>> singletonFactories，存放可以生成Bean的工厂（FactoryBean），用于生产（创建）对象

/** Cache of singleton objects: bean name to bean instance. */
// 一级缓存：singleton对象的缓存：bean名称 - bean实例。
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/** Cache of singleton factories: bean name to ObjectFactory. */
// 三级缓存：单例工厂的缓存：bean名称 - ObjectFactory
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);/** Cache of early singleton objects: bean name to bean instance. */
// 二级缓存：早期singleton对象的缓存：bean名称 - bean实例。
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

四大方法

getSingleton()：从容器里面获得单例的bean，没有的话则会创建 bean
doCreateBean()：执行创建 bean 的操作（在 Spring 中以 do 开头的方法都是干实事的方法）
populateBean()：创建完 bean 之后，对 bean 的属性进行填充
addSingleton()：bean 初始化完成之后，添加到单例容器池中，下次执行 getSingleton() 方法时就能获取到

三级缓存中的迁移

A创建过程中需要B，于是A将自己放到三级缓存里面，去实例化B
B实例化的时候发现需要A，于是B先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了A，然后把三级缓存里面的这个A放到二级缓存里面，并删除三级缓存里面的A
B顺利初始化完毕，将自己放到一级缓存里面（此时B里面的A依然是创建中状态），然后回来接着创建A，此时B已经创建结束，直接从一级缓存里面拿到B，然后完成创建，并将A自己放到一级缓存里面。