@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;
}

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

// 模擬 Bean 定義
class BeanDefinition {
    private String beanName;
    private Class<?> beanClass;

    public BeanDefinition(String beanName, Class<?> beanClass) {
        this.beanName = beanName;
        this.beanClass = beanClass;
    }

    public String getBeanName() {
        return beanName;
    }

    public Class<?> getBeanClass() {
        return beanClass;
    }
}

// 模擬 Spring 容器
class BeanFactory {
    // 一級(jí)緩存
    private final Map<String, Object> singletonObjects = new HashMap<>();
    // 二級(jí)緩存
    private final Map<String, Object> earlySingletonObjects = new HashMap<>();
    // 三級(jí)緩存
    private final Map<String, Supplier<Object>> singletonFactories = new HashMap<>();
    // Bean 定義集合
    private final Map<String, BeanDefinition> beanDefinitions = new HashMap<>();

    // 注冊(cè) Bean 定義
    public void registerBeanDefinition(BeanDefinition beanDefinition) {
        beanDefinitions.put(beanDefinition.getBeanName(), beanDefinition);
    }

    // 獲取 Bean
    public Object getBean(String beanName) {
        // 先從一級(jí)緩存中查找
        Object singletonObject = singletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }
        // 再從二級(jí)緩存中查找
        singletonObject = earlySingletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }
        // 從三級(jí)緩存中查找
        Supplier<Object> singletonFactory = singletonFactories.get(beanName);
        if (singletonFactory != null) {
            // 創(chuàng)建早期引用
            singletonObject = singletonFactory.get();
            // 將早期引用放入二級(jí)緩存
            earlySingletonObjects.put(beanName, singletonObject);
            // 從三級(jí)緩存中移除
            singletonFactories.remove(beanName);
            return singletonObject;
        }
        // 創(chuàng)建 Bean
        BeanDefinition beanDefinition = beanDefinitions.get(beanName);
        if (beanDefinition != null) {
            try {
                // 創(chuàng)建 Bean 實(shí)例
                Object bean = beanDefinition.getBeanClass().newInstance();
                // 將 Bean 工廠放入三級(jí)緩存
                singletonFactories.put(beanName, () -> bean);
                // 模擬屬性注入，可能會(huì)出現(xiàn)循環(huán)依賴
                // 這里簡單處理，不進(jìn)行實(shí)際的屬性注入
                // ...
                // 屬性注入完成后，將 Bean 放入一級(jí)緩存
                singletonObjects.put(beanName, bean);
                // 從二級(jí)緩存中移除
                earlySingletonObjects.remove(beanName);
                return bean;
            } catch (InstantiationException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

// 測(cè)試類
public class Main {
    public static void main(String[] args) {
        BeanFactory beanFactory = new BeanFactory();
        // 注冊(cè) Bean 定義
        beanFactory.registerBeanDefinition(new BeanDefinition("beanA", BeanA.class));
        beanFactory.registerBeanDefinition(new BeanDefinition("beanB", BeanB.class));
        // 獲取 Bean
        Object beanA = beanFactory.getBean("beanA");
        Object beanB = beanFactory.getBean("beanB");
        System.out.println("BeanA: " + beanA);
        System.out.println("BeanB: " + beanB);
    }
}

// 示例 Bean A
class BeanA {
    private BeanB beanB;

    public BeanA() {
    }

    public BeanB getBeanB() {
        return beanB;
    }

    public void setBeanB(BeanB beanB) {
        this.beanB = beanB;
    }
}

// 示例 Bean B
class BeanB {
    private BeanA beanA;

    public BeanB() {
    }

    public BeanA getBeanA() {
        return beanA;
    }

    public void setBeanA(BeanA beanA) {
        this.beanA = beanA;
    }
}

+---------------------+
| 一級(jí)緩存 (singletonObjects) |
| 存放完全初始化的 Bean  |
+---------------------+
           ^
           |
           |
+---------------------+
| 二級(jí)緩存 (earlySingletonObjects) |
| 存放早期曝光的 Bean  |
+---------------------+
           ^
           |
           |
+---------------------+
| 三級(jí)緩存 (singletonFactories) |
| 存放 ObjectFactory 對(duì)象 |
+---------------------+

@Component
public class A {
    private B b;
    public A(B b) { this.b = b; }  // 構(gòu)造器注入
}
 
@Component
public class B {
    private A a;
    public B(A a) { this.a = a; }  // 構(gòu)造器注入
}

@Component
public class A {
    @Lazy  // 延遲注入B
    @Autowired
    private B b;
}

@Order(3)
public class UserProxy {}

@Order(1)
public class PersonProxy {}

@Component
@DependsOn({"beanB", "beanC"})  // 確保beanB和beanC先加載
public class BeanA {
    // ...
}

@Component
public class BeanB {
    // ...
}

@Component
public class BeanC {
    // ...
}

@Component
public class BeanOne implements PriorityOrdered {
    @Override
    public int getOrder() {
        return 1;  // 數(shù)字越小優(yōu)先級(jí)越高
    }
}

@Component
public class BeanTwo implements Ordered {
    @Override
    public int getOrder() {
        return 2;
    }
}

@Component
@Order(1)
public class FirstBean {
    // ...
}

@Component
@Order(2)
public class SecondBean {
    // ...
}

@Component
public class A {
    @Autowire
    private B b;
}