Java Spring处理循环依赖详解

@Component("foo")
public Class Foo {
    @Autowired
    private Bar bar;  // 称 foo 依赖 bar
}

@Component("bar")
public Class Bar {
    @Autowired
    private Baz baz;  // bar 依赖 baz
}

@Component("baz")
public class Baz {
    @Autowired
    private Foo foo; // 形成了循环依赖，baz -> (依赖) foo -> bar -> baz ...
}

org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'bar': Requested bean is currently in creation: Is there an unresolvable circular reference?

if (earlySingletonExposure) {
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

@Component
public class Foo {
    private Bar bar;
    @Autowired
    public Foo(@Lazy Bar bar) {
        this.bar = bar;
    }
}

@Component
public class Bar {
    private Foo foo;
    @Autowired
    public Bar(Foo foo) {  // 或者将对 foo 的依赖，注解为 @Lazy 表示使用时才初始化
        this.foo = foo;
    }
}

@Component
public class Bar {
    private Foo foo;
    @Autowired
    public void setFoo(Foo foo) {
        this.foo = foo;
    }
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        // 缓存中存在
        /**
        * 如果 beanName 是一个 FactoryBean，则获取对应的 Bean
        * 如果 beanName 是一个普通的 Bean，则返回这个 Bean 本身
        */ 
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        // 缓存中不存在
        // 创建对象
        
        if (mbd.isSingleton()) {
            /**
            * 这里的 getSingleton 是 getSingleton(beanName) 的重载版本
            * 它接受一个 beanName 和 一个 ObjectFactory 作为参数
            * 调用 ObjectFactory#getObject 产生一个实例
            * 并通过 addSingleton(beanName, singletonObject); 将实例添加到 singletonObjects 中
            * 这里 createBean 的代码就是前面提到的 Spring 创建 Bean 实例的过程 doCreateBean
            */
            sharedInstance = getSingleton(beanName, () -> {
                try {
                    return createBean(beanName, mbd, args);
                }
            });
            /**
            * 同前面分支中的作用一样
            */
            beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
    }
    /**
    * 判断 Bean 类型与 requiredType 类型是否一直，一致则直接返回，不一致则需要进行转换
    */
    return adaptBeanInstance(name, beanInstance, requiredType);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // Quick check for existing instance without full singleton lock
    Object singletonObject = this.singletonObjects.get(beanName);
    /**
    * 判断第一级缓存中是否有完全可以可用的 Bean 实例，若有则返回；
    * 若没有，则根据情况判断
    * isSingletonCurrentlyInCreation(beanName) 检查的是在 `Set<String> singletonsCurrentlyInCreation` 集合中是否包含要获取的 Bean 实例
    * beanName 只在调用 beforeSingletonCreation(String beanName)  时被添加到 singletonsCurrentlyInCreation 集合中
    * beforeSingletonCreation 在创建 bean，即 doCreateBean 之前调用，在创建过程完成以后，调用 afterSingletonCreation 从集合中移除 beanName
    */
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
        /**
        * 执行到这个分支，其实说明 Bean 已经在创建过程中了，只不过是尚未完全可用（即一级缓存中没有）
        * 检查二级缓存，是否包含指定的 Bean
        * 
        * 二级缓存里的内容何时被添加或设置进来的呢？
        * 我们可以检查下 earlySingletonObjects.put 方法都在哪里调用。
        * 检查后发现，其实 earlySingletonObjects 就是在当前方法中设置的，我们接着往下看。
        */
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            /**
            * 这里的 allowEarlyReference 的意思就是指是否允许在二级缓存中创建一个对象，即是否允许暴露未完全可用的对象
            * 如果 allowEarlyReference 为假，则不会操作二级、三级缓存，而仅检查一级缓存中是否有完全可用的 Bean 实例
            * 这也意味着，不允许返回未完全可用状态的 Bean
            * 
            * 当发现二级缓存中没有对象，同时又允许提前引用（即 allowEarlyReference 值为真）
            * 则检查三级缓存中是否有对应的 ObjectFactory 对象，若有，则调用它的 getObject 方法产生对象，然后将其放置到二级缓存中，同时删除三级缓存中的对象工厂实例
            * 若三级缓存中也没有对象工厂实例，则说面 bean 还未创建
            */
            synchronized (this.singletonObjects) {
                /**
                * 这里会进行一个 double-check，避免多线程间的线程安全问题
                */
                // Consistent creation of early reference within full singleton lock
                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) {
                            /**
                            * 三级缓存中存在对象工厂实例，则通过它产生一个 Bean 实例
                            * 加入到二级缓存中，同时删除三级缓存中的对象工厂实例
                            */
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

sharedInstance = getSingleton(beanName, () -> {
    try {
        return createBean(beanName, mbd, args);
    }
});

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            /**
            * 检查 Bean 是否在创建过程中，避免重复创建，
            * 不能解决的循环依赖也是在这里抛出异常
            */
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            try {
                /**
                * 这里调用的其实就是  AbstractAutowireCapableBeanFactory#createBean
                * 然后会执行 doCreateBean（三个阶段）
                */
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                throw ex;
            }
            finally {
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                /**
                * 这里说明一个 bean 创建过程的三个阶段都执行完毕了
                */
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}
/**
* 将 Bean 实例添加到第一级缓存
* 将第二级、第三级缓存中的对象删除
*/
protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}