Spring中循环依赖问题的解决机制及详细流程

@Service
public class A {
    @Autowired
    private B b;
}
@Service
public class B {
    @Autowired
    private A a;
}

// 一级缓存：存放完全初始化好的Bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存：存放原始的Bean对象（尚未填充属性），用于解决循环依赖
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三级缓存：存放Bean工厂对象，用于解决循环依赖
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

@Service
public class UserService {
    @Autowired
    private OrderService orderService;
    public void findUserOrders(Long userId) {
        System.out.println("查询用户订单");
        orderService.getOrdersByUserId(userId);
    }
}
@Service
public class OrderService {
    @Autowired
    private UserService userService;
    public List<Order> getOrdersByUserId(Long userId) {
        System.out.println("获取用户订单");
        return new ArrayList<>();
    }
    public void notifyUser(Long orderId) {
        System.out.println("通知用户订单状态");
        userService.findUserOrders(1L); // 调用UserService的方法
    }
}

1. 实例化UserService对象（仅调用构造函数，此时内部属性尚未赋值）
2. 将UserService实例的创建工厂添加到三级缓存（singletonFactories）中
   singletonFactories.put("userService", () -> getEarlyBeanReference(beanName, mbd, userService实例))
3. 开始填充UserService的属性，发现需要注入OrderService

1. 实例化OrderService对象（仅调用构造函数）
2. 将OrderService实例的创建工厂添加到三级缓存中
   singletonFactories.put("orderService", () -> getEarlyBeanReference(beanName, mbd, orderService实例))
3. 开始填充OrderService的属性，发现需要注入UserService

1. OrderService需要注入UserService，但UserService正在创建中
2. Spring尝试从一级缓存(singletonObjects)查找UserService，未找到
3. 继续从二级缓存(earlySingletonObjects)查找UserService，未找到
4. 最后从三级缓存(singletonFactories)中找到UserService的工厂对象
5. 调用工厂对象的getObject()方法获取UserService的早期引用
   - 如果UserService需要被代理（如有@Transactional注解），此时会创建代理对象
   - 如果不需要代理，则返回原始对象
6. 将获取到的UserService早期引用放入二级缓存，同时从三级缓存中移除
   earlySingletonObjects.put("userService", userService早期引用)
   singletonFactories.remove("userService")
7. 将UserService的早期引用注入到OrderService中

1. OrderService完成属性填充（已注入UserService的早期引用）
2. OrderService完成初始化（调用各种初始化方法）
3. 如果OrderService需要被代理，创建代理对象（AOP）
4. 将完全初始化好的OrderService放入一级缓存
   singletonObjects.put("orderService", 完全初始化的orderService)
5. 返回到UserService的属性填充流程，将完全初始化好的OrderService注入到UserService中
6. UserService完成初始化
7. 如果UserService需要被代理且之前没有提前创建代理，创建代理对象
8. 将完全初始化好的UserService放入一级缓存
   singletonObjects.put("userService", 完全初始化的userService)

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 首先从一级缓存查找
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果一级缓存没有，且该Bean正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 从二级缓存查找
        singletonObject = this.earlySingletonObjects.get(beanName);
        // 如果二级缓存也没有，且允许早期引用
        if (singletonObject == null && allowEarlyReference) {
            // 从三级缓存获取工厂
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
                // 通过工厂获取早期引用
                singletonObject = singletonFactory.getObject();
                // 放入二级缓存
                this.earlySingletonObjects.put(beanName, singletonObject);
                // 从三级缓存移除
                this.singletonFactories.remove(beanName);
            }
        }
    }
    return singletonObject;
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        // 如果一级缓存中不存在
        if (!this.singletonObjects.containsKey(beanName)) {
            // 添加到三级缓存
            this.singletonFactories.put(beanName, singletonFactory);
            // 确保二级缓存中不存在
            this.earlySingletonObjects.remove(beanName);
            // 记录注册的单例
            this.registeredSingletons.add(beanName);
        }
    }
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = 
                    (SmartInstantiationAwareBeanPostProcessor) bp;
                // 这里可能创建代理对象
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

@Service
@Transactional
public class UserService {
    // ...
}
@Service
@Transactional
public class OrderService {
    // ...
}