public class Demo {
    public static void main(String[] args) {
        new Demo1();
    }
}
class Demo1{
    private Demo2 demo2 = new Demo2();
}
class Demo2 {
    private Demo1 demo1 = new Demo1();
}

public class Demo {
    /**
     * 保存提前暴露的對(duì)象,也就是半成品對(duì)象
     */
    private final static Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    public static void main(String[] args) throws Exception {
        System.out.println(getBean(Demo1.class).getDemo2());
        System.out.println(getBean(Demo2.class).getDemo1());
    }
    private static <T> T getBean(Class<T> clazz) throws Exception {
        // 獲取beanName
        String beanName = clazz.getName().toLowerCase();
        // 查找緩存中是否存在半成品對(duì)象
        if (singletonObjects.containsKey(beanName)) {
            return (T) singletonObjects.get(beanName);
        }
        // 緩存中不存在半成品對(duì)象,反射進(jìn)行實(shí)例化
        T res = clazz.newInstance();
        // 將實(shí)例化后的對(duì)象儲(chǔ)存到緩存
        singletonObjects.put(beanName, res);
        // 獲取所有屬性
        Field[] fields = res.getClass().getDeclaredFields();
        // 循環(huán)進(jìn)行屬性填充
        for (Field field : fields) {
            // 針對(duì)private修飾
            field.setAccessible(Boolean.TRUE);
            // 獲取屬性類型
            Class<?> fieldClazz = field.getType();
            // 獲取屬性beanName
            String filedBeanName = fieldClazz.getName().toLowerCase();
            // 屬性填充,查找緩存是否有對(duì)應(yīng)屬性,沒有就遞歸調(diào)用
            field.set(res, singletonObjects.containsKey(filedBeanName) ? singletonObjects.get(filedBeanName) : getBean(fieldClazz));
        }
        return res;
    }
}
class Demo1 {
    private Demo2 demo2;
    public Demo2 getDemo2() {
        return demo2;
    }
    public void setDemo2(Demo2 demo2) {
        this.demo2 = demo2;
    }
}
class Demo2 {
    private Demo1 demo1;
    public Demo1 getDemo1() {
        return demo1;
    }
    public void setDemo1(Demo1 demo1) {
        this.demo1 = demo1;
    }
}

/**
     * 添加對(duì)象到三級(jí)緩存
     *
     * @param beanName
     * @param singletonFactory
     */
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    // 確保singletonFactory不為null
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    // 使用singletonObjects進(jìn)行加鎖,保證線程安全
    synchronized (this.singletonObjects) {
        //如果singletonObjects緩存中沒有該對(duì)象
        if (!this.singletonObjects.containsKey(beanName)) {
            // 將對(duì)象放置到singletonFactories(三級(jí)緩存)中
            this.singletonFactories.put(beanName, singletonFactory);
            // 從earlySingletonObjects(二級(jí)緩存)中移除該對(duì)象
            this.earlySingletonObjects.remove(beanName);
            // 將beanName添加到已經(jīng)注冊(cè)的單例集中
            this.registeredSingletons.add(beanName);
        }
    }
}

/**
     * 返回在給定名稱下注冊(cè)的(原始)單例對(duì)象.檢查已經(jīng)實(shí)例化的單例,并允許對(duì)當(dāng)前創(chuàng)建的單例進(jìn)行早期引用(解決循環(huán)引用)
     *
     * @param beanName
     * @param allowEarlyReference
     * @return
     */
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 不需要完全獲取單例鎖的情況下快速檢查現(xiàn)有實(shí)例
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果單例對(duì)象為空,并且當(dāng)前單例正在創(chuàng)建中,則嘗試獲取早期單例對(duì)象
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        // 如果早期單例對(duì)象為空,并且允許早期引用,則再完全獲取單力所的情況下創(chuàng)建早期單例對(duì)象
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // 檢查早期單例對(duì)象是否存在
                singletonObject = this.singletonObjects.get(beanName);
                // 如果早期對(duì)象仍然為空則創(chuàng)建單例對(duì)象
                if (singletonObject == null) {
                    // 從二級(jí)緩存獲取
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        // 獲取不到對(duì)象從三級(jí)緩存中獲取
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();
                            // 獲取到添加到二級(jí)緩存并從三級(jí)緩存中移除該對(duì)象
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

/**
     * 將單例對(duì)象添加到一級(jí)緩存
     *
     * @param beanName
     * @param singletonObject
     */
protected void addSingleton(String beanName, Object singletonObject) {
    // 使用singletonObjects進(jìn)行加鎖,保證線程安全
    synchronized (this.singletonObjects) {
        // 將映射關(guān)系添加到一級(jí)緩存
        this.singletonObjects.put(beanName, singletonObject);
        // 從三級(jí)緩存;二級(jí)緩存中移除該對(duì)象
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        // 將beanName添加到已經(jīng)注冊(cè)的單例集中
        this.registeredSingletons.add(beanName);
    }
}