Spring源码解析系列之循环依赖解决之道（二）
前言：
本篇内容实际上是续上一篇的，循环依赖问题在Spring里面很常见，比如我有一个类A，里面依赖了类B（如@Autowired注入），类B又依赖了类C，类C又依赖类A，那么就形成了一个循环依赖圈子。如果你配置了Spring的原型模式或者使用构造器注入，那么出现循环依赖就会抛异常导致依赖注入失败；如果使用单例模式并使用值注入，Spring会很巧妙的处理这个问题。我们接下来就看看Spring是怎么巧妙的解决这个问题的。
1、Bean在内存中的几种形态：
实际上这几个状态我们在上一篇已经讲的很清楚了，这里去掉概念态再啰嗦一遍。
- 定义态：即BeanDefinition的形式，BeanDefination里包含了该Bean的各种信息，包括应该由哪个类创建、是否是单例、是否允许提前引用等等，这是BeanFactory创建Bean的原材料。想象一辆奥迪车，现在的奥迪只是一本设计图纸，得去工厂里拿着个图纸生产才能有车。
- 纯净态：此时的Bean还没有被设置各种属性，所有的属性都处于原始态即false 0 null等。此时的奥迪车还的引擎、轮胎、方向盘还都是空壳，只挂了一个四个圈的logo，并不能真正的为人类服务。
- 成熟态：此时的Bean中的属性已经被注入了真正的值，真正的能提供服务了。奥迪已经被装上了引擎、轮胎、方向盘等，可以真正的行驶起来了。
2、存储Bean的三级缓存（三个Map）
从上到下为一级缓存，二级缓存，三级缓存。
/** 缓存单例对象Bean名称-->Bean实例: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
/** 缓存单例的提前曝光对象单例名称-->提前曝光的对象: bean name --> bean instance */
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
/** 缓存创建单例的工厂Bean名称-->单例工厂: bean name --> ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
三级缓存图
3、循环依赖处理过程
我们以类A、B、C为例，A注入B，B注入C，C注入A。
- 首先：创建A对象，如果支持循环依赖就创建一个纯净的A对象
- 然后：给A对象属性赋值的时候由于A对象依赖B对象，因此创建一个纯净态的B对象
- 再次：给B对象的属性赋值的时候由于B对象依赖C对象，在C对象属性赋值过程中发现依赖A对象，由于内存中已经有一个纯净态的A对象了，因此直接注入纯净态的A对象
- 最后：接着完成B、A（注意顺序）两个对象从纯净态变为成熟态的创建工作
4、循环依赖代码说明
上面简约的介绍了循环依赖处理流程，本部分承接上一篇并结合代码进行细致分析。
首先、所有的bean创建都会调用这个方法。
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
-----省略次要代码
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
------省略次要代码
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
------省略次要代码
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
-------捕获异常
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
-------原型模式，不考虑循环依赖
-------省略次要代码------
return (T) bean;
}
然后、上面创建bean的方法内部首先调用了以下方法，提前检测了三个缓存里是否有对象存在。显然我们第一次创建A对象的时候三个缓存里都不存在。所以返回的对象是null的。
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
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 != NULL_OBJECT ? singletonObject : null);
}
然后、创建bean的方法内部由调用了下面的方法，该方法定义了一个匿名内部类ObjectFactory，所以调用getSingleton方法的时候里边的getObject（）方法实际调用的就是匿名内部类的方法。我们先看getSingleton方法，代码就不贴了，该方法内部首先把A对象加入到一个map里，表明A对象正在创建，然后执行匿名内部类的createBean方法。
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
-------捕获异常
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
接着、上面的匿名内部类的createBean方法最后调用到了如下方法，该方法首先判断A对象是否该被提前曝光，显然此处A对象符合提前曝光的条件，执行if语句中代码addSingletonFactory方法，该方法我们贴到下面了，该方法主要把A对象的ObjectFacotry创建工厂提前曝光到一级缓存中了。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
------省略-----
//A对象在前面的方法里已经被加入到正在创建中的map里，所以此处为 true
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
----debuglog省略
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
------异常
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
}
-----省略
}
return exposedObject;
}
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
接着、上面的addSingletonFactory提前曝光了A对象的创建工厂后，对A对象进行populateBean-->applyPropertyValues--〉valueResolver.resolveValueIfNecessary(pv, originalValue)调用链调用，即给A对象属性赋值，当赋值到B引用的时候调用了resolveValueIfNecessary方法，该方法内部又调用resolveReference方法，这个方法内部又调用了getBean-->doGetBean这个调用链去创建B对象。
public Object resolveValueIfNecessary(Object argName, Object value) {
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
return resolveReference(argName, ref);
}
-------省略其他代码----------
}
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
try {
String refName = ref.getBeanName();
refName = String.valueOf(doEvaluate(refName));
if (ref.isToParent()) {
if (this.beanFactory.getParentBeanFactory() == null) {
--------异常
}
return this.beanFactory.getParentBeanFactory().getBean(refName);
}
else {
Object bean = this.beanFactory.getBean(refName);
this.beanFactory.registerDependentBean(refName, this.beanName);
return bean;
}
}
---------省略----------
}
然后、由于A对象会阻塞在populateBean方法等待B对象的bean被创建，B对像创建过程中执行到populateBean的时候又会等待C对象创建，最后C对象执行到populateBean的时候，由于调用了getBean（A）所以回到第一步的doGetBean方法的getSingleton（beanName）快速获取，该方法获取到的就是一级缓存里提前曝光的A的ObjectFactory工厂生产的纯静态A对象。然后C对象完成了populateBean的依赖注入，返回CBean到B的populate调用处，B的populateBean执行完依赖注入，返回BBean到A的populateBean处，完成A的依赖注入。至此三个对象的依赖注入完成！
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
-----省略次要代码
//看这里看这里看这里快看呐！！！！！！！！！！！！！！！
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
------省略次要代码
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
------省略次要代码
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
-------捕获异常
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
-------原型模式，不考虑循环依赖
-------省略次要代码------
return (T) bean;
}
总结：
以上就是Spring处理循环依赖的步骤，关键在于对象状态和三级缓存。如果有兴趣可以自己debug下，另外要理解循环依赖和循环调用的区别。
