一文彻底搞懂spring循环依赖

前言

在关于Spring的面试中，我们经常会被问到一个问题：Spring是如何解决循环依赖问题的？这个问题
算是关于Spring的一个高频面试题，如果不刻意研读，即使度过源码，面试者也不一定能够一下子回答得上。

本文主要针对这个问题，从源码角度对其实现原理进行剖析。

1.什么是循环依赖？

循环依赖其实就是对象之间的循环引用，即两个或两个以上的Bean互相持有对方，最终形成闭环。

用代码的形式演示，更容易理解，如下是ClassA和ClassB的声明：

public class ClassA {

	private ClassB classB;

	public ClassB getClassB() {
		return classB;
	}

	public void setClassB(ClassB classB) {
		this.classB = classB;
	}
}

public class ClassB {

	private ClassA classA;

	public ClassA getClassA() {
		return classA;
	}

	public void setClassA(ClassA classA) {
		this.classA = classA;
	}
}

2.循环依赖处理机制？

• 单例bean构造器参数方式循环依赖（无法解决）

  首先先来演示通过构造器参数方式的循环依赖，结合源码来分析，为什么构造器参数的方式无法解决循环依赖。

  // 触发所有非延迟加载单例bean的初始化，主要步骤为getBean
  for (String beanName : beanNames) {
  	// 合并父BeanDefinition对象
  	// map.get(beanName)
  	RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  	if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  		if (isFactoryBean(beanName)) {
  			Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  			// 如果是FactoryBean则加&
  			if (bean instanceof FactoryBean) {
  				final FactoryBean<?> factory = (FactoryBean<?>) bean;
  				boolean isEagerInit;
  				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  					isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
  									((SmartFactoryBean<?>) factory)::isEagerInit,
  							getAccessControlContext());
  				}
  				else {
  					isEagerInit = (factory instanceof SmartFactoryBean &&
  							((SmartFactoryBean<?>) factory).isEagerInit());
  				}
  				if (isEagerInit) {
  					getBean(beanName);
  				}
  			}
  		}
  		else {
  			// 实例化当前bean
  			getBean(beanName);
  		}
  	}
  }
  

进入getBean()方法

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

再次进入到doGetBean()方法

首先会尝试从缓存中获取对象，此时还没有这个对象，接着往下看

这里会将每一个正在创建的BeanName放入singletonsCurrentlyInCreation集合中，该集合在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry中定义。

private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

接着往下走，执行到singletonObject = singletonFactory.getObject()，会进入到前面的lamda表达式中的createBean方法中。

进入doCreateBean方法中，这里会有几个比较重要的几个部分，此步骤是将对象实例化。

接下将实例化的对象提前暴露到singletonFactories（也就是三级缓存）中

进入addSingletonFactory方法里

接着往下执行，来到populateBean方法，这里就是判断当前bean是否依赖了其他的bean，如果依赖了，就会递归的调用getBean()方法尝试获取目标bean

进入方法内部，执行到applyPropertyValues

进入applyPropertyValues方法内部

接下来就是重点了，进入方法内部，找到bean = this.beanFactory.getBean(refName)这行代码。

这里发现ClassA对象依赖于ClassB对象，又回到getBean()方法，但是要注意的是，此时getBean里的参数是classB，此时容器中还不存在ClassB这个对象，又回到创建ClassB的过程，执行到属性装配的步骤时，ClassB对象又依赖于ClassA对象，又回到之前的步骤，执行到getSingleton中的beforeSingletonCreation(beanName)方法时，发现此时ClassA已经存在singletonsCurrentlyInCreation这个集合中了，接着会抛出异常，整个过程结束。（这也是为什么构造器参数形式不支持循环依赖的原因）

Error creating bean with name 'classA' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'classB' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'classB' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'classA' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'classA': Requested bean is currently in creation: Is there an unresolvable circular reference?

• prototype原型bean方式循环依赖（无法解决）

  
  ClassA对象在创建之前，会进行标记这个bean正在被创建，等创建之后会将标记删除。

  进入beforePrototypeCreation方法，看一下此方法都做了哪些事。

这里可以看到，prototypesCurrentlyInCreation是一个ThreadLocal，ThreadLocal是什么呢？其实它就是一个线程局部变量，它的功能就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。也就是说，此处会将beanName存放到线程局部变量中，后面创建对象的时候，首先会查看这个局部变量是否有值，如果没有值，说明这个对象还没有进行创建，会进入到创建对象的步骤，如果检测到这个beanName已存在，就会抛出异常。这也是为什么prototype原型bean方式循环依赖无法解决的原因。

Error creating bean with name 'classA' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'classB' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'classB' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'classA' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'classA': Requested bean is currently in creation: Is there an unresolvable circular reference?

• singleton单例bean的setter方式循环依赖

  再来看一下singleton单例bean的settter方式的循环依赖，它是通过提前暴露一个ObjectFactory对象来完成的，简单来说ClassA在调用构造器完成对象初始化之后，在调用ClassA的setClassB方法之前就把ClassA实例化的对象通过ObjectFactory提前暴露到Spring容器中，ClassA调用setClassB方法，Spring首先尝试从容器中获取ClassB，此时ClassB不存在，Spring容器初始化ClassB，同时也将ClassB暴露到Spring容器中，ClassB调用setClassA方法，Spring从容器中获取ClassA，因为之前已经提前暴露了ClassA，因此可以获取到ClassA实例，ClassA通过给Spring容器获取到ClassB，完成对象初始化操作，这样ClassA和ClassB都完成了对象初始化操作，解决了循环依赖问题。

3.Spring如何解决循环依赖问题？

Spring正是通过singleton单例bean的setter方式解决循环依赖的，ClassA在创建的时候，会将自己放入到singletonObjectFactories三级缓存中，在属性装配的时候，检测到ClassA对象依赖于ClassB对象，Spring首先尝试从容器中获取ClassB，此时ClassB不存在，Spring容器会初始化ClassB，同时也将ClassB暴露到容器中，接着就是对ClassB进行属性装配，Spring从容器中获取ClassA，因为之前已经将ClassA暴露到容器中了，因此可以获取到ClassA实例，并将ClassA升级放入二级缓存earlySingletonObjects中，ClassA通过给Spring容器获取到ClassB，完成了ClassB的初始化操作，这样ClassA和ClassB都完成了对象初始化操作，便解决了循环依赖问题。

ClassA升级放入earlySingletonObjects的代码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	Object singletonObject = this.singletonObjects.get(beanName);
	// 判断当前单例bean是否正在创建中
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			singletonObject = this.earlySingletonObjects.get(beanName);
			// 是否允许从singletonFactories中通过getObject拿到对象
			if (singletonObject == null && allowEarlyReference) {
				// 从三级缓存中取出单例对象工厂
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
					singletonObject = singletonFactory.getObject();
					// 从三级缓存移动到了二级缓存
					this.earlySingletonObjects.put(beanName, singletonObject);
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

ClassB初始化完成放入单例池的代码（此步骤是对ClassA进行属性装配时，发现ClassB不存在，将会对ClassB

进行创建，属性装配，对象初始化等一系列步骤执行完之后）

protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) {
	// 将此bean（已成型的Spring Bean）移入一级缓存（单例池）
		this.singletonObjects.put(beanName, singletonObject);
		this.singletonFactories.remove(beanName);
		this.earlySingletonObjects.remove(beanName);
		this.registeredSingletons.add(beanName);
	}
}

那么ClassB对象完成了ClassB的初始化操作，这样ClassA和ClassB都完成了对象初始化操作。ClassA形成最终的Spring Bean对象之后，会将其放入单例池中，代码同上。

到这里，Spring整个解决循环依赖问题的实现思路已经比较清楚了。对于整体过程，读者朋友只要理解两点：

• Spring是通过递归的方式获取目标bean及其所依赖的bean的；

• Spring实例化一个bean的时候，是分两步进行的，首先实例化目标bean，然后为其注入属性。

也就是说，Spring在实例化一个bean的时候，是首先递归的实例化其所依赖的所有bean，直到某个bean没有依赖其他bean，此时就会将该实例返回，然后反递归的将获取到的bean设置为各个上层bean的属性的。