Spring如何处理循环依赖

1.什么是循环依赖？

<bean id="A" class="com.test.A">
    <constructor-arg index="0" ref="B">
    </constructor-arg>
</bean>
<bean id="B" class="com.test.B">
    <constructor-arg index="0" ref="A">
    </constructor-arg>
</bean>

@Component
public class A {
  private B b;
  public A(B b) {
    this.b = b;
  }
}
@Component
public class B {
  private A a;
  public B(A a) {
    this.a = a;
  }
}

    两个或多个bean相互引用，最终形成一个闭环，就是循环依赖。

2.Spring能解决什么样的循环依赖

    Spring不能解决所有形式的循环依赖，上例中，使用构造器注入形成的循环依赖Spring就无法解决，Spring可以解决基于Setter方法注入的单例bean的循环依赖。因为Spring解决循环是基于Java的引用传递实现的，当获取对象引用时，对象的属性可以延后设置。但是使用构造器是设置属性必须是在获取引用之前。

3.如何解决循环依赖

    Spring创建循环依赖对象的过程大致如下：

    1.当通过ApplicationContext.getBean()方法获取A对象时，首先Spring会在容器中查找是否已经存在对象A的实例，如果没有就会创建一个对象A的实例，如果已经存在就直接使用已存在的实例（Spring解决循环依赖的前提是Bean的作用域是单例模式）。
    2.在创建A对象实例的过程中，发现A对象依赖B对象，Spring会通过递归方式再通过getBean()方法去创建B对象，创建方式跟第一步一样。
    3.在创建B对象的过程中，发现B对象依赖A对象，因为第一步时已经创建过A对象的实例，这时就会直接将第一步创建的A对象赋值给B对象的属性a。需要注意的是，这里的对象A只创建了一半，因为A的属性b还没有设置完成。
    4.B对象创建完成之后，就会被设置到A对象的属性b中。这里的A对象其实就是第3步中B对象中的半成品属性a的引用对象。引用地址是一致的。这时为A对象设置了b属性，其实也就是将第3步中的B对象的a属性创建完毕。

    Spring解决循环依赖是使用三级缓存的机制：

    一级缓存：单例缓存池singletonObjects；
    二级缓存：早期提前暴露的对象缓存earlySingletonObjects；
    三级缓存：singletonFactories单例对象工厂缓存。
    提前暴露对象：上例中的A对象就是提前暴露对象，当给B对象的a属性设置A对象实例时，A对象还没有创建完成（属性b还未设置）。 Spring实现三级缓存的源代码如下：

        protected T doGetBean(final String name, @Nullable final Class requiredType, 
	@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		//在缓存中获取对象
		Object sharedInstance = getSingleton(beanName);
		//单例对象
		if (mbd.isSingleton()) {
			sharedInstance = getSingleton(beanName,()-> {
				try {
				    return createBean(beanName, mbd, args);
				} catch (BeansException ex) {
					throw ex;
				}
			});
		}
		return (T) bean;
	}

	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		//尝试从一级缓存获取对象，如果存在，直接返回
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果一级缓存中不存在目标对象，判断当前对象是否正在创建，也就是二级缓存对象
		if (singletonObject == null && isSingletonCurrentlyCreation(beanName)) {
			synchronized (this.singletonObjects) {
				//二级缓存获取
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					//这里的singletonFactories是一个Map，key是bean的名称，value是ObjectFactory类型
					//的对象。对于上面的例子而言，通过其getObject()方法返回的就是A和B对象。
					ObjectFactrory singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, 
	    final @Nullable Object[] args) throws BeanCreationException {
			//实例化当前尝试获取的bean对象
			BeanWrapper instanceWrapper = null;
			if (mbd.isSingleton()) {
				instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
			}
			if (instanceWrapper == null) {
				instanceWrapper = createBeanInstance(beanName, mbd, args);
			}
			//判断是否支持提前暴露目标bean
			boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCirularReferences 
			&& isSingletonCurrentlyInCreation(beanName);
			if (earlySingletonExposure) {
				//将创建好的Bean放入三级缓存，并移除早期暴露的对象。
				addSingletonFactory(beanName, ()->getEarlyBeanReference(beanName, mbd, bean));
			}
			try {
				populateBean(beanName, mbd, instanceWrapper);
			} catch (Throwable ex) {
				//......
			}
			return exposedObject;
		}

    1.首先初始化A
    2.调用doGetBean(A)方法；
    3.Object sharedInstance = getSingleton(A)，因为A是第一次初始化，所以缓存中无法获取到；
    4.调用createBeanInstance(A)方法，因为B是A通过Autowired关联的，所以初始化A时不会对B进行初始化；
    5.调用addSingletonFactory方法，此时将初始化A，将还没有设置属性b的A对象放入三级缓存singletonFactory中；
    6.调用populateBean(A)，因为A中Autowired了B，将触发getBean(B);
    7.调用doGetBean(B)方法；
    8.Object sharedInstance = getSingleton(B)；因为此时B首次初始化，所以在缓存中无法获取到；
    9.调用createBeanInstance(B)方法；
    10.调用addSingletonFactory，将B对象放入三级缓存；
    11.调用populateBean(B)，因为B对象Autowired了A，那么将触发getBean(A)；
    12.再次触发doGetBean(A);
    13.Object sharedInstance = getSingleton(A);因为这个时候A是第二次初始化，直接从三级缓存中直接获取第5步放进去的对象。