@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對象（尚未填充屬性），用于解決循環(huán)依賴
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三級緩存：存放Bean工廠對象，用于解決循環(huán)依賴
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("通知用戶訂單狀態(tài)");
        userService.findUserOrders(1L); // 調(diào)用UserService的方法
    }
}

1. 實例化UserService對象（僅調(diào)用構(gòu)造函數(shù)，此時內(nèi)部屬性尚未賦值）
2. 將UserService實例的創(chuàng)建工廠添加到三級緩存（singletonFactories）中
   singletonFactories.put("userService", () -> getEarlyBeanReference(beanName, mbd, userService實例))
3. 開始填充UserService的屬性，發(fā)現(xiàn)需要注入OrderService

1. 實例化OrderService對象（僅調(diào)用構(gòu)造函數(shù)）
2. 將OrderService實例的創(chuàng)建工廠添加到三級緩存中
   singletonFactories.put("orderService", () -> getEarlyBeanReference(beanName, mbd, orderService實例))
3. 開始填充OrderService的屬性，發(fā)現(xiàn)需要注入UserService

1. OrderService需要注入UserService，但UserService正在創(chuàng)建中
2. Spring嘗試從一級緩存(singletonObjects)查找UserService，未找到
3. 繼續(xù)從二級緩存(earlySingletonObjects)查找UserService，未找到
4. 最后從三級緩存(singletonFactories)中找到UserService的工廠對象
5. 調(diào)用工廠對象的getObject()方法獲取UserService的早期引用
   - 如果UserService需要被代理（如有@Transactional注解），此時會創(chuàng)建代理對象
   - 如果不需要代理，則返回原始對象
6. 將獲取到的UserService早期引用放入二級緩存，同時從三級緩存中移除
   earlySingletonObjects.put("userService", userService早期引用)
   singletonFactories.remove("userService")
7. 將UserService的早期引用注入到OrderService中

1. OrderService完成屬性填充（已注入UserService的早期引用）
2. OrderService完成初始化（調(diào)用各種初始化方法）
3. 如果OrderService需要被代理，創(chuàng)建代理對象（AOP）
4. 將完全初始化好的OrderService放入一級緩存
   singletonObjects.put("orderService", 完全初始化的orderService)
5. 返回到UserService的屬性填充流程，將完全初始化好的OrderService注入到UserService中
6. UserService完成初始化
7. 如果UserService需要被代理且之前沒有提前創(chuàng)建代理，創(chuàng)建代理對象
8. 將完全初始化好的UserService放入一級緩存
   singletonObjects.put("userService", 完全初始化的userService)

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 首先從一級緩存查找
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果一級緩存沒有，且該Bean正在創(chuàng)建中
    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;
                // 這里可能創(chuàng)建代理對象
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

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