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 {
    /**
     * 保存提前暴露的對象,也就是半成品對象
     */
    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();
        // 查找緩存中是否存在半成品對象
        if (singletonObjects.containsKey(beanName)) {
            return (T) singletonObjects.get(beanName);
        }
        // 緩存中不存在半成品對象,反射進行實例化
        T res = clazz.newInstance();
        // 將實例化后的對象儲存到緩存
        singletonObjects.put(beanName, res);
        // 獲取所有屬性
        Field[] fields = res.getClass().getDeclaredFields();
        // 循環(huán)進行屬性填充
        for (Field field : fields) {
            // 針對private修飾
            field.setAccessible(Boolean.TRUE);
            // 獲取屬性類型
            Class<?> fieldClazz = field.getType();
            // 獲取屬性beanName
            String filedBeanName = fieldClazz.getName().toLowerCase();
            // 屬性填充,查找緩存是否有對應(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;
    }
}

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

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

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