流程图+源码方式理解Spring如何解决循环依赖
抛个问题
为什么构造器的循环依赖不能解决，setter循环依赖可以解决？
构造器的依赖，自定义了构造方法，且构造方法中依赖其他Bean。
public class BeanC {
private BeanA beanA;
public BeanC(BeanA beanA) {
this.beanA = beanA;
}
}
前驱知识点
我们平常使用最多的Spring容器ApplicationContext初始化时会实例化所有的单例Bean。
Bean默认加载方式为非懒加载方式
Bean的作用域默认为单例。
什么是循环依赖
多个Bean之间的依赖关系形成闭环。如下面的例子：BeanA依赖BeanB，BeanB依赖BeanA。导致Spring在实例化时会发现有循环依赖。
public class BeanA {
private BeanB beanB;
public BeanB getBeanB() {
return beanB;
}
public void setBeanB(BeanB beanB) {
this.beanB = beanB;
}
}
public class BeanB {
private BeanA beanA;
public BeanA getBeanA() {
return beanA;
}
public void setBeanA(BeanA beanA) {
this.beanA = beanA;
}
}
循环依赖具体在哪发生
获取Bean的大致过程
循环依赖问题发生在设置Bean属性(populateBean)，初始化Bean时若发现依赖其他Bean则会递归去调用get(其他Bean)直至所有依赖的Bean都初始化完成再设置本身的依赖。
以上面例子为例简单看一下 get(BeanA)的流程(setter依赖方式)：
解决方式
Spring解决循环依赖浓缩为一句话为：Eagerly cache singletons to be able to resolve circular references，即提前将已实例化的但还未设置依赖的bean实例缓存起来，即实例化之后设置依赖属性之前。
解决的点在实例化Bean doCreateBean这一步
解决后的过程：
需要注意的几点：
-
从临时Map获取的Bean实例时仍未初始化完成的，还未设置属性值。
-
BeanB初始化完成时拿到的仍是BeanA未完全初始化的实例
-
BeanA递归调用获取依赖的BeanB，BeanB初始化完成后，回到了设置BeanA属性方法
-
当BeanA初始化完成后，此时BeanA和BeanB才算是真正的初始化完成。
-
BeanB从临时缓存拿的BeanA实例和实例化BeanA的实例是同一个，java的引用嘛
源码解读
注：源码基于org.springframework:spring-beans:5.2.5.RELEASE
友情提示：只列出了关键的源码。不要试图理解每一步源码的逻辑，spring的源码可能一行源码中包含了多个知识点，这样只会越陷越深。所以我们只需要理解关键步骤即可。
public abstract class AbstractBeanFactory{
//入口方法，可以从该方法一步步跟进
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
}
protected <T> T doGetBean(final String name,
@Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly)
throws BeansException {
//先从缓存中获取bean实例
Object sharedInstance = getSingleton(beanName);
if (sharedInstance == null) {
//缓存中没有则创建Bean
return createBean(beanName, mbd, args);
}
}
//先从缓存中获取bean实例，singletonFactories为临时缓存Map
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//singletonObjects保存已经加载好的Bean实例
Object singletonObject = this.singletonObjects.get(beanName);
//此时Bean还未初始化为null，isSingletonCurrentlyInCreation判断beanName是否为正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
//singletonFactories缓存正在创建的A实例，实例化时会put Bean实例
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
//createBean方法调用了doCreateBean
protected Object doCreateBean(final String beanName,
final RootBeanDefinition mbd, final @Nullable
Object[] args) throws BeanCreationException {
// Instantiate the bean.
//实例化Bean，下面代码段不需要重点关注
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//关键点 判断 是否为单例&&是否允许循环依赖&&且Bean是否正在创建中
boolean earlySingletonExposure = (mbd.isSingleton()
&& this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
//***解决循环依赖关键点，缓存正在创建的实例
addSingletonFactory(beanName,
() -> getEarlyBeanReference(beanName, mbd, bean));
}
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
//将实例化后的Bean放入临时缓存Map singletonFactories，对应getSingleton方法看
protected void addSingletonFactory(String beanName,
ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
//缓存实例，对应getSingleton方法中的get
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
//设置Bean的依赖 递归去获取依赖的Bean
protected void populateBean(String beanName, RootBeanDefinition mbd,
@Nullable BeanWrapper bw) {
if (resolvedAutowireMode == AUTOWIRE_BY_NAME
|| resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
//设置Bean的属性，这里以通过name设置举例。
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
}
protected void autowireByName(String beanName, AbstractBeanDefinition mbd,
BeanWrapper bw, MutablePropertyValues pvs) {
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
//若有依赖则继续获取依赖的Bean。
Object bean = getBean(propertyName);
}
}
}
回到开始的问题
相信将上面的流程看完就明白了为什么spring不能解决构造器的循环依赖了。解决循环的关键点在于使用Bean默认的构造方式先实例化Bean，然后将实例Bean临时缓存起来，让其依赖的Bean去获取。而构造器方式需要先获取依赖的Bean，然后才能自定义的构造器创建自己的Bean实例，所以无法解决循环依赖问题。
如有不实，还望指正