[读书笔记]Spring中的循环依赖详解

什么是循环依赖？

循环依赖就是N个类中循环嵌套引用，如果在日常开发中我们用new 对象的方式发生这种循环依赖的话程序会在运行时一直循环调用，直至内存溢出报错。

那么Spring是如何解决循环依赖的？

【1】Spring循环依赖的三种方式

① 构造器参数循环依赖

Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中，因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出BeanCurrentlyInCreationException异常表示循环依赖。而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。

首先我们先初始化三个Bean。

public class StudentA {
	private StudentB studentB ;
	public void setStudentB(StudentB studentB) {
		this.studentB = studentB;
	}
	public StudentA() {
	}
	public StudentA(StudentB studentB) {
		this.studentB = studentB;
	}
}

public class StudentB {
	private StudentC studentC ;
	public void setStudentC(StudentC studentC) {
		this.studentC = studentC;
	}
	public StudentB() {
	}
	public StudentB(StudentC studentC) {
		this.studentC = studentC;
	}
}
public class StudentC {
	private StudentA studentA ;
	public void setStudentA(StudentA studentA) {
		this.studentA = studentA;
	}
	public StudentC() {
	}
	public StudentC(StudentA studentA) {
		this.studentA = studentA;
	}
}

也就是A依赖B，B依赖C，C依赖A。如果这时候创建实例A，将会抛出如下异常：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:
Error creating bean with name 'a': Requested bean is currently in creation:
Is there an unresolvable circular reference?

Spring容器先创建单例StudentA，StudentA依赖StudentB，然后将A放在“当前创建Bean池”中，此时创建StudentB,StudentB依赖StudentC ,然后将B放在“当前创建Bean池”中,此时创建StudentC，StudentC又依赖StudentA， 但是，此时StudentA已经在池
中，所以会报错，，因为在池中的Bean都是未初始化完的，所以会依赖错误 ，（初始化完的Bean会从池中移除）。

下图来源于网络

② set方法注入单例

如果要说setter方式注入的话，我们最好先看一张Spring中Bean实例化的图

如图中前两步骤得知：Spring是先将Bean对象实例化之后再设置对象属性的。

这时候我们再次获取StudentA对象将会成功获取到。

public class Test {
	public static void main(String[] args) {
		ApplicationContext context = new
		ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");
		System.out.println(context.getBean("a", StudentA.class));
	}
}

那么为什么此时不会发生循环依赖异常呢？我们结合上面那张图看，Spring先是用构造实例化Bean对象 ，此时Spring会将这个实例化结束的对象放到一个Map中，并且Spring提供了获取这个未设置属性的实例化对象引用的方法。

结合我们的实例来看，当Spring实例化了StudentA、StudentB、StudentC后，紧接着会去设置对象的属性，此时StudentA依赖StudentB，就会去Map中取出存在里面的单例StudentB对象，以此类推，不会出现循环的问题。

---

我们常用的可能是如下方式：

@Component
public class StudentA {
    @Autowired
    StudentB studentB;
}

@Component
public class StudentB {
    @Autowired
    StudentC studentc;
}

@Component
public class StudentC {

    @Autowired
    StudentA studentA;
}

// 如下测试代码
@Api(tags = {"意见反馈"})
@Controller
@RequestMapping({"/advice","home/advice"})
public class SysAdviceController {

    @Autowired
    StudentA studentA;

    @ResponseBody
    @RequestMapping("/test")
    public ResponseBean test(){
        System.out.println("************************"+studentA);
        return ResultUtil.success();
    }
    //...
}    

这里我们可以看下获取的对象，其同样是完成了正常的实例化，并没有出现循环依赖异常。可以说这样属性注入本质与setXXX单例是一样的。

---

③ setter方式原型，prototype

scope="prototype" 意思是 每次请求都会创建一个实例对象。两者的区别是：有状态的bean都使用Prototype作用域，无状态的一般都使用singleton单例作用域。

这里直接说明测试结果：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:
Error creating bean with name 'a': Requested bean is currently in creation:
Is there an unresolvable circular reference?

对于“prototype”作用域Bean，Spring容器无法完成依赖注入，因为“prototype”作用域的Bean，Spring容器不进行缓存，因此无法提前暴露一个创建中的Bean。

【2】从源码角度看Spring如何解决循环依赖

Spring的三级缓存

其实这里要了解Spring的三级缓存。下面是DefaultSingletonBeanRegistry中的一些常量：

• 一级缓存 Map<String, Object> singletonObjects
• 二级缓存 Map<String, Object> earlySingletonObjects
• 三级缓存 Map<String, ObjectFactory<?>> singletonFactories

// 一级缓存，存放beanName和Bean instance
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 三级缓存  bean name - -objectFactory
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

// 二级缓存，存放beanName和Bean instance  early：早期的
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

// 注册序列的bean名称--单例哦
/** Set of registered singletons, containing the bean names in registration order. */
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

// 正在创建的bean的名称
/** Names of beans that are currently in creation. */
private final Set<String> singletonsCurrentlyInCreation =
		Collections.newSetFromMap(new ConcurrentHashMap<>(16));

在[读书笔记]IOC容器的依赖注入详解我们看到了Bean创建的过程。

如上图所示，在doGetBean的方法中首先调用DefaultSingletonBeanRegistry的getSingleton(java.lang.String, boolean)方法尝试拿到单例缓存(也就是前面创建的，但是还可能没有完全完成bean的实例化)。

getSingleton方法是用来急切地检查手动注册的单例缓存。其允许当前创建的单例暴露出去，用来解决循环依赖。

// AbstractBeanFactory#doGetBean
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存里面获取
	Object singletonObject = this.singletonObjects.get(beanName);
	// 如果一级缓存获取不到，且beanName是正在创建的Bean
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
	// 对一级缓存加锁
		synchronized (this.singletonObjects) {
			//从二级缓存里面获取
			singletonObject = this.earlySingletonObjects.get(beanName);
			
			// allowEarlyReference 这里传入的是true  允许bean提前暴露
			// 如果二级缓存里面没有，则从三级缓存获取工厂
			if (singletonObject == null && allowEarlyReference) {
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
				// 得到工厂生产的bean
					singletonObject = singletonFactory.getObject();
					// 放入二级缓存
					this.earlySingletonObjects.put(beanName, singletonObject);
					// 从三级缓存移除
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

如果这里获取到了会直接调用bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);获取最终bean实例。然后判断是否需要格式化，之后返回。

如果这里获取不到，那么就会走创建流程。最终我们会在AbstractAutowireCapableBeanFactory的doCreateBean方法中看到这样的关键几步：

// 创建对象
instanceWrapper = createBeanInstance(beanName, mbd, args);

//单例  允许循环引用  是当前正在创建的bean，则调用addSingletonFactory  allowCircularReferences 默认为true
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");
	}
	// 放到三级缓存
	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// 依赖注入，实例化后期处理
Object exposedObject = bean;
try {
	// 属性赋值，解析依赖，循环依赖也发生在这个过程
	populateBean(beanName, mbd, instanceWrapper);
	// bean实例化的后置处理，比如beanpostprocessor   init-method等
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}

我们看下这个addSingletonFactory方法，这个方法让那些需要迫切注册单例，例如能够解析循环引用场景使用。

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
	Assert.notNull(singletonFactory, "Singleton factory must not be null");
	synchronized (this.singletonObjects) {//对一级缓存加锁
		if (!this.singletonObjects.containsKey(beanName)) { //如果一级缓存不存在该bean
			this.singletonFactories.put(beanName, singletonFactory);//放入三级缓存
			this.earlySingletonObjects.remove(beanName);//从二级缓存移除
			this.registeredSingletons.add(beanName);//放入bean名称
		}
	}
}

这样当执行到populateBean时 ，如果两个对象相互依赖，那么当前对象(假设为A)的实例化就会触发另外一个对象(假设为B)的实例化。当B实例化时其又依赖了A就会从三级缓存(或二级缓存)获取A的引用完成实例化从而最终完成A的实例化。

那么二级缓存在这里面的作用呢?

假设AB相互依赖，AC相互依赖。那么B实例化后，就该进行C的实例化，这时C就可以从二级缓存来获取A的实例引用了，就不需要再从三级缓存获取工厂让其生产实例。

即假设只有AB相互依赖，其他对象不依赖AB时，这里二级缓存是没用的，一级和三级缓存起作用。

那么什么时候放入一级缓存呢？

仍旧在AbstractBeanFactory的doGetBean方法中。如下代码所示，首先运行createBean方法，其次会调用getSingleton方法。

// Create bean instance.
if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			// Explicitly remove instance from singleton cache: It might have been put there
			// eagerly by the creation process, to allow for circular reference resolution.
			// Also remove any beans that received a temporary reference to the bean.
			destroySingleton(beanName);
			throw ex;
		}
	});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

这里调用的getSingleton方法是getSingleton(String beanName, ObjectFactory<?> singletonFactory),如下所示如果未从一级缓存得到singletonObject ，那么其会调用addSingleton(beanName, singletonObject);方法。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	Assert.notNull(beanName, "Bean name must not be null");
	synchronized (this.singletonObjects) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			if (this.singletonsCurrentlyInDestruction) {
				throw new BeanCreationNotAllowedException(beanName,
						"Singleton bean creation not allowed while singletons of this factory are in destruction " +
						"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
			}
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			}
			catch (IllegalStateException ex) {
				// Has the singleton object implicitly appeared in the meantime ->
				// if yes, proceed with it since the exception indicates that state.
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					throw ex;
				}
			}
			catch (BeanCreationException ex) {
				if (recordSuppressedExceptions) {
					for (Exception suppressedException : this.suppressedExceptions) {
						ex.addRelatedCause(suppressedException);
					}
				}
				throw ex;
			}
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				afterSingletonCreation(beanName);
			}
			if (newSingleton) {
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;
	}
}

addSingleton(beanName, singletonObject);方法如下所示：

protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) {
		// 放入一级缓存
		this.singletonObjects.put(beanName, singletonObject);
		// 从三级缓存移除
		this.singletonFactories.remove(beanName);
		// 从二级缓存移除
		this.earlySingletonObjects.remove(beanName);
		// 放入registeredSingletons中
		this.registeredSingletons.add(beanName);
	}
}

参考博文：
[读书笔记]IOC容器的依赖注入详解