Spring三级缓存及其解决循环依赖的过程

Spring 的两种循环依赖：

1. 构造器循环依赖： 当 Bean A 的构造函数依赖于 Bean B，而 Bean B 的构造函数又依赖于 Bean A 时，就会发生构造器循环依赖。
2. 属性循环依赖： 当 Bean A 的属性依赖于 Bean B，而 Bean B 的属性又依赖于 Bean A 时，就会发生属性循环依赖。

三级缓存

1. singletonObjects： 用于存储已经完全初始化完成的 Bean 实例。当 Bean 完成初始化后，会被放入 singletonObjects 缓存中，之后进行依赖注入时可以直接获取
2. earlySingletonObjects：当 Spring 容器检测到循环依赖时，会将尚未完全初始化的 Bean 实例放入 earlySingletonObjects 缓存中
3. singletonFactories： 当 Spring 容器检测到循环依赖时，会将正在创建 Bean 实例的 ObjectFactory 放入 singletonFactories 缓存中

三级缓存的工作机制

1. 当 Spring 容器开始创建一个 Bean 实例时，会先检查 singletonObjects 缓存中是否存在该 Bean 的实例，如果存在则直接返回
2. 如果 singletonObjects 缓存中不存在该 Bean 的实例，但是在 earlySingletonObjects 缓存中存在，则说明该 Bean 正在创建中，此时会尝试从 singletonFactories 缓存中获取 Bean 的 ObjectFactory
3. 如果三级缓存都不存在该 Bean 的实例，则说明该 Bean 尚未被创建，Spring 容器会先将 Bean 的 ObjectFactory 放入 singletonFactories 缓存中，然后创建该 Bean 的实例，并在创建完成后放入 singletonObjects 缓存中

如果还是有些模糊，下面是一个完整的例子
假设有两个 Bean，Bean A 依赖于 Bean B，而 Bean B 又依赖于 Bean A。其创建过程如下：

1. Spring 容器开始创建 Bean A，首先会检查 singletonObjects 缓存中是否存在 Bean A 的实例，发现尚未创建过 Bean A
2. Spring 容器创建 Bean A 的实例，并将其放入 earlySingletonObjects 缓存中，表示 Bean A 正在创建中。然后，容器会继续解析 Bean A 的依赖关系，发现 Bean A 依赖于 Bean B
3. Spring 容器开始创建 Bean B，首先会检查 singletonObjects 缓存中是否存在 Bean B 的实例，发现尚未创建过 Bean B
4. Spring 容器创建 Bean B 的实例，并将其放入 earlySingletonObjects 缓存中，表示 Bean B 正在创建中。然后，容器会继续解析 Bean B 的依赖关系，发现 Bean B 依赖于 Bean A
5. 此时，Spring 容器需要获取 Bean A 的实例来完成 Bean B 的创建。因为 Bean A 正在创建中，所以无法从 singletonObjects 缓存中获取。容器会从 singletonFactories 缓存中获取 Bean A 的 ObjectFactory
6. 容器通过调用 Bean A 的 ObjectFactory 获取 Bean A 的实例，并将其放入 singletonObjects 缓存中，表示 Bean A 创建完成。然后，继续完成 Bean B 的初始化，并完成依赖注入
7. 容器完成 Bean B 的初始化后，将 Bean B 的实例放入 singletonObjects 缓存中，表示 Bean B 创建完成

最终，容器完成 Bean A 和 Bean B 的创建，可以在其他地方进行引用和使用。