spring5.3 九：循环依赖底层分析

循环依赖底层分析

什么是循环依赖？
很简单，就是A对象依赖了B对象，B对象依赖了A对象。

// A依赖了B
class A{
 public B b;
}

// B依赖了A
class B{
 public A a;
}

在Spring中，一个对象并不是简单new出来了，而是会经过一系列的Bean的生命周期，就是因为Bean的生命周期所以才会出现循环依赖问题。当然，在Spring中，出现循环依赖的场景很多，有的场景Spring自动帮我们解决了，而有的场景则需要程序员来解决。
之前分析的spring生命周期的核心方法doCreateBean 这其中就包含了循环依赖的过程，循环依赖的过程在BeanDefinition后置处理和属性填充之间。

// 为了解决循环依赖提前缓存单例创建工厂
		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// this.allowCircularReferences 是否支持循环依赖 默认为true
		// singletonsCurrentlyInCreation 是一个set集合 spring会把正在创建的beanNam加入到这个集合
		// isSingletonCurrentlyInCreation(beanName) 判断singletonsCurrentlyInCreation 是否存在 这个beanName
		// 也就是判断当前beanName 是不是正在创建中  如果是说明需要处理循环依赖
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			// 循环依赖-添加到三级缓存  把当前beanNam 和一个lambda表达式存到一个map当中  这个map就是 三级缓存
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

在循环依赖之前spring就经历了实例化，所以会得到一个原始对象，Spring需要给原始对象中的属性进行依赖注入，那么这个注入过程是怎样的？
比如上文说的A类，A类中存在一个B类的b属性，所以，当A类生成了一个原始对象之后，就会去给b属性去赋值，此时就会根据b属性的类型和属性名去BeanFactory中去获取B类所对应的单例bean。如果此时BeanFactory中存在B对应的Bean，那么直接拿来赋值给b属性；如果此时BeanFactory中不存在B对应的Bean，则需要生成一个B对应的Bean，然后赋值给b属性。
问题就出现在第二种情况，如果此时B类在BeanFactory中还没有生成对应的Bean，那么就需要去生成，就会经过B的Bean的生命周期。
那么在创建B类的Bean的过程中，如果B类中存在一个A类的a属性，那么在创建B的Bean的过程中就需要A类对应的Bean，但是，触发B类Bean的创建的条件是A类Bean在创建过程中的依赖注入，所以这里就出现了循环依赖：
ABean创建–>依赖了B属性–>触发BBean创建—>B依赖了A属性—>需要ABean（但ABean还在创建过程中）
从而导致ABean创建不出来，BBean也创建不出来。
那么spring是如何解决这个循环依赖的呢？spring利用了三级缓存的机制解决这个问题。

三级缓存
三级缓存是通用的叫法。
一级缓存为：singletonObjects
二级缓存为：earlySingletonObjects
三级缓存为：singletonFactories

singletonObjects中缓存的是已经经历了完整生命周期的bean对象。
earlySingletonObjects比singletonObjects多了一个early，表示缓存的是早期的bean对象。早期是什么意思？表示Bean的生命周期还没走完就把这个Bean放入了earlySingletonObjects。
singletonFactories中缓存的是ObjectFactory，表示对象工厂，表示用来创建早期bean对象的工厂。

解决循环依赖思路分析
A创建时—>需要B---->B去创建—>需要A，从而产生了循环

那么如何打破这个循环，加个中间人（缓存）

从上面这个分析过程中可以得出，只需要一个缓存就能解决循环依赖了，那么为什么Spring中还需要singletonFactories呢？
这是难点，基于上面的场景想一个问题：如果A的原始对象注入给B的属性之后，A的原始对象进行了AOP产生了一个代理对象，此时就会出现，对于A而言，它的Bean对象其实应该是AOP之后的代理对象，而B的a属性对应的并不是AOP之后的代理对象，这就产生了冲突。
说的简单点就是B依赖的A和最终的A不是同一个对象。
AOP就是通过一个BeanPostProcessor来实现的，这个BeanPostProcessor就是AnnotationAwareAspectJAutoProxyCreator，它的父类是AbstractAutoProxyCreator，而在Spring中AOP利用的要么是JDK动态代理，要么CGLib的动态代理，所以如果给一个类中的某个方法设置了切面，那么这个类最终就需要生成一个代理对象。
一般过程就是：A类—>生成一个普通对象–>属性注入–>基于切面生成一个代理对象–>把代理对象放入singletonObjects单例池中。
而AOP可以说是Spring中除开IOC的另外一大功能，而循环依赖又是属于IOC范畴的，所以这两大功能想要并存，Spring需要特殊处理。如何处理的，就是利用了第三级缓存singletonFactories。
上面展示源码部分的核心代码

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		//this.singletonObjects 单例池
		synchronized (this.singletonObjects) {
			//判断单例池中有没有这个bean  比如A创建需要依赖B  那么这个bean就是A
			if (!this.singletonObjects.containsKey(beanName)) {
				//把A放入到三级缓存当中
				this.singletonFactories.put(beanName, singletonFactory);
				//从二级缓存中移除
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			}
		}
	}

首先，singletonFactories中存的是某个beanName对应的ObjectFactory，在bean的生命周期中，生成完原始对象之后，就会构造一个ObjectFactory存入singletonFactories中。这个ObjectFactory是一个函数式接口，所以支持Lambda表达式：() -> getEarlyBeanReference(beanName, mbd, bean)

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
				//核心方法   判断是否需要aop 来决定返回代理对象还是原始对象
				exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
			}
		}
		return exposedObject;
	}

该方法会去执行SmartInstantiationAwareBeanPostProcessor中的getEarlyBeanReference方法，它的实现如下：

public Object getEarlyBeanReference(Object bean, String beanName) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		//记录信息  后续初始化后会根据 这个map 进行判断 需要不需要调用wrapIfNecessary 方法
		this.earlyProxyReferences.put(cacheKey, bean);
		// 核心方法  判断需不需要进行aop 需要的话返回代理对象  不需要的话放回原始对象
		return wrapIfNecessary(bean, beanName, cacheKey);
	}

执行addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));方法只是将ObjectFactory记录到三级缓存中并没有执行lambda表达式。那什么时候执行这个表达式呢，例如开头的案例，创建A时把A的ObjectFactory记录到三级缓存，因为A依赖B，所以接着创建B，创建B，而B又依赖A最终自然要执行getBean(A)方法获取A的bean。在getBean方法中会执行getSingleton(beanName);从单例池中获取bean.也就是此时会执行A的lambda表达式

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		//从单例池中获取对象
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果拿到了 直接return
		// 如果拿不到   isSingletonCurrentlyInCreation 判断是不是正在创建中
		// isSingletonCurrentlyInCreation 是一个set集合 会把正在创建的beanName加入到这个集合
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			// 如果是正在创建中  从二级缓存获取bean
			//earlySingletonObjects 是一个map 表示二级缓存  存放的是半成品的bean
			singletonObject = this.earlySingletonObjects.get(beanName);
			// 如果从二级缓存拿不到 进入到这个if  拿到了 直接return
			if (singletonObject == null && allowEarlyReference) {
				synchronized (this.singletonObjects) {
					// 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) {
							//从三级缓存获取对象  三级缓存是一个map  beanName为可以  一个lambda表达式为value
							//从三级缓存中拿 lambda表达式
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								//执行lambda表达式
								// 执行完后返回一个原始对象(相当于无参构造 创建处理来的对象) 或者是代理对象  称之为半成品的对象
								singletonObject = singletonFactory.getObject();
								// 把半成品的对象放入到 二级缓存中 然后从三级缓存中移除
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

那么B最终会从二级缓存中拿到原始对象或者代理对象。成功创建B，那么A因为B成功创建也能创建出来。循环依赖还是比较复杂的，下面来总结
总结
首先总结下三级缓存分别有什么作用
一级缓存(singletonObjects)：缓存经过了完整生命周期的bean。
二级缓存(earlySingletonObjects)：缓存未经过完整生命周期的bean，在循环依赖过程中，二级缓存的是三级缓存中的lambda表达式的结果，该表达式返回的是原始对象，那么就缓存原始对象，如果返回代理对象那么就缓存代理对象。这个表达式就是判断该bean需不需要AOP，需要则返回代理对象，不需要则返回原始对象
三级缓存(singletonFactories)：缓存的是一个ObjectFactory，也就是一个Lambda表达式。在每个Bean的生成过程中，经过实例化得到一个原始对象后，都会提前基于原始对象暴露一个Lambda表达式，并保存到三级缓存中，这个Lambda表达式可能用到，也可能用不到，如果当前Bean没有出现循环依赖，那么这个Lambda表达式没用。如果出现循环依赖就会调用这个表达式

总结一下循环依赖的过程，比如A依赖B，B也依赖A。

1. spring开始A的生命周期，到了实例化阶段会实例化一个A的ObjectFactory，存入三级缓存中具体方法对应addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));。
2. 由于A依赖B，那么开始创建B。
3. 同样B的生命周期到了实例化阶段也会创建B的ObjectFactory，存入三级缓存中。由于B依赖A，那么就会创建A。创建A就会调用doGetBean方法
4. 在doGetBean方法中会执行getSingleton方法获取A的bean对象。首先通过单例池获取A，获取不到，通过二级缓存获取A，也获取不到，通过三级缓存获取A，获取到了A的ObjectFactory，然后用ObjectFactory的lambda表达式，根据是否需要AOP返回代理对象还是原始对象，存入二级缓存中，同时返回这个对象。
5. 此时B所依赖的A就有半成品的bean对象，那么B的生命周期也就能完成
6. B的生命周期完成后存入一级缓存也就是单例池中，然后接着完成A的生命周期
7. A通过getSingleton方法获取B的bean对象，首先从单例池中获取，能够获取到，那么A的生命周期也能够完成，然后A放入到一级缓存中。