Spring循环依赖代码演示及解决方案

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();
        // 循环进行属性填充
        for (Field field : fields) {
            // 针对private修饰
            field.setAccessible(Boolean.TRUE);
            // 获取属性类型
            Class<?> fieldClazz = field.getType();
            // 获取属性beanName
            String filedBeanName = fieldClazz.getName().toLowerCase();
            // 属性填充,查找缓存是否有对应属性,没有就递归调用
            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添加到已经注册的单例集中
            this.registeredSingletons.add(beanName);
        }
    }
}

/**
     * 返回在给定名称下注册的(原始)单例对象.检查已经实例化的单例,并允许对当前创建的单例进行早期引用(解决循环引用)
     *
     * @param beanName
     * @param allowEarlyReference
     * @return
     */
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 不需要完全获取单例锁的情况下快速检查现有实例
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果单例对象为空,并且当前单例正在创建中,则尝试获取早期单例对象
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        // 如果早期单例对象为空,并且允许早期引用,则再完全获取单力所的情况下创建早期单例对象
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // 检查早期单例对象是否存在
                singletonObject = this.singletonObjects.get(beanName);
                // 如果早期对象仍然为空则创建单例对象
                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) {
        // 将映射关系添加到一级缓存
        this.singletonObjects.put(beanName, singletonObject);
        // 从三级缓存;二级缓存中移除该对象
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        // 将beanName添加到已经注册的单例集中
        this.registeredSingletons.add(beanName);
    }
}