背景
bean在创建过程中会出现各种各样的循环依赖。了解spring如何用三级缓存机制解决循环依赖，解决spring没有解决的循环依赖。所以需要了解bean的生命周期原理。
出现属性的循环依赖时，bean的生命周期
spring用三级缓存机制来解决属性的循环依赖。
以 UserService 和 OrderService 出现属性的循环依赖为例子。
示例代码
@Component
public class OrderService {
@Autowired
UserService userService;
}
@Component
public class UserService {
@Autowired
OrderService orderService;
}
orderService 添加入set集合
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
singletonsCurrentlyInCreation 存储正在创建的 beanName ，后面用来检查是否出现了循环依赖。
这里把 "orderService" 添加进这集合。
创建bean的普通对象
createBeanInstance 中推断构造函数，然后实例化bean并返回
instanceWrapper = createBeanInstance(beanName, mbd, args);
将 orderService 添加到三级缓存中
三级缓存 singletonFactories 存储的是一个lambda 表达式。这个表达式用来存储 生成 orderService 对象的过程。后面出现循环依赖的时候会用到
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
orderService 属性填充
populateBean 会给 orderService 做属性填充，把 UserService 填充进去。在这里，会进入 UserService 的生命周期。
populateBean(beanName, mbd, instanceWrapper);
三级缓存中生成 orderService
UserService 的生命周期的步骤同上 orderService 的生命周期。
这里直接看到给 UserService 的bean生命周期中，对 字段 orderService 的属性注入过程。
这里需要把 orderService 从三级缓存中获取出来，然后放入二级缓存，如果需要AOP 这里会提前进行 AOP。
（注：这里二级缓存是为了，防止 UserService 出现多个循环依赖时，不生成多个代理对象。而存在，这里就不放开解释了。）
...
// 从 三级缓存 singletonFactories 里面找
// 获取到 lambda 表达式
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 执行 lambda 表达式
singletonObject = singletonFactory.getObject();
// 把结果放到 二级缓存 earlySingletonObjects 里面
this.earlySingletonObjects.put(beanName, singletonObject);
...
这里从三级缓存中获取到 orderService 并完成 UserService 的生命周期。
orderService 的AOP阶段
这里如果循环依赖提前进行了AOP 就不会再进行AOP获取代理对象了。
earlyProxyReferences 缓存的就是 执行lambda 表达式获取的 bean
private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
orderService 放入单例池
因为出现了循环依赖所以从二级缓存中获取bean，放入单例池
把 orderService 从 set集合中删除
orderService 的生命周期结束，已经不是正在创建的 bean。所以这里把 orderService 从 set集合中 remove。
构造方法的循环依赖解决
构造方法的循环依赖，spring的三级缓存机制是解决不了的
因为卡在了创建普通对象，构造方法执行不了，普通对象都创建不成功
@Component
public class DemoAService {
public DemoAService(DemoBService demoBService) {
}
}
@Component
public class DemoBService {
public DemoBService(DemoAService demoAService) {
}
}
但是 加上 @Lazy 注解可以解决
@Lazy 不真正创建对象，返回一个代理对象。用的时候才会创建对象。
普通对象创建不成功，不影响
这里加上一个 @Lazy 就能解决
@Component
public class DemoAService {
@Lazy
public DemoAService(DemoBService demoBService) {
}
}
@Component
public class DemoBService {
public DemoBService(DemoAService demoAService) {
}
}
async 注解的循环依赖
同上。
给属性加上 @Lazy 之后，不存在循环依赖了。
加上 @Lazy 创建代理对象，执行的时候才会真正的创建对象。