1. 情况1：setter循环依赖
<beans:bean id="beanC" class="cn.spy.spring.source.code.BeanC">
<beans:property name="beanD" ref="beanD"></beans:property>
</beans:bean>
<beans:bean id="beanD" class="cn.spy.spring.source.code.BeanD">
<beans:property name="beanC" ref="beanC"></beans:property>
</beans:bean>
2. 情况2：构造器循环依赖
<beans:bean id="beanA" class="cn.spy.spring.source.code.BeanA">
<beans:constructor-arg name="beanB" ref="beanB"></beans:constructor-arg>
</beans:bean>
<beans:bean id="beanB" class="cn.spy.spring.source.code.BeanB">
<beans:constructor-arg name="beanA" ref="beanA"></beans:constructor-arg>
</beans:bean>
spring4 IOC获取单例对象方式
循环依赖只出现在单例模式中，如果是原型模式，那么每次需要依赖对象直接创建新对象，也就不会出现循环依赖问题了。
// 使用给定的名称注册单例对象
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 检查缓存中是否存在实例
Object singletonObject = this.singletonObjects.get(beanName);
// 如果不存在并且判断当前单例方式创建beanName
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 给缓存上锁
synchronized (this.singletonObjects) {
// 如果此beanName对应的bean实例正在加载则不会再处理
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果单例对象为空并且允许早期依赖
if (singletonObject == null && allowEarlyReference) {
// 获取beanName对应的单例bean工厂
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
// 单例bean工厂不为空
if (singletonFactory != null) {
// 调用预先设定的getObject方法
singletonObject = singletonFactory.getObject();
// 将单例bean设置在earlySingletonObjects缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
// 将单例bean从earlySingletonObjects缓存中移除
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
循环依赖的三级缓存：
① singletonObjects：一级缓存
② earlySingletonObjects：二级缓存
③ singletonFactories：三级缓存，单例bean工厂缓存，缓存singletonFactory
说明：
- 如果singletonObjects缓存中已经存在单例bean，直接返回。
- 否则查找earlySingletonObjects缓存中是否已经存在单例bean，如果存在，什么也不操作。
- 如果不存在，那么通过beanName获取singletonFactories缓存中的singletonFactory单例工厂。
- 单例工厂不为空，那么就singletonFactory.getObject()方法创建singletonObject，然后设置到earlySingletonObjects缓存（二级缓存）中，从singletonFactories缓存中移除。
spring4 解决setter循环依赖
beanC和beanD通过setter方式相互依赖，spring4 IOC通过提前曝光的方式来解决循环依赖。
// 向容器中缓存单例Bean对象，以防循环引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 为了防止循环引用，尽早持有对象的引用
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// 向singletonFactories缓存设置singletonFactory
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);
}
}
}
说明：
将实例对象实例化之后（createBeanInstance），spring采用提前曝光的方式，将生产bean的工厂singletonFactory，缓存到singletonFactories中。（将实例化对象开了个后门，可以提前获取到实例对象）
设置到一级缓存singletonObjects
重载getSingleton方法来实现设置一级缓存
入口：AbstractBeanFactory中doGetBean方法
// 创建单例Bean的实例对象
if (mbd.isSingleton()) {
// 获取到单例bean（匿名内部类方式实现）
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
// 创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 如果捕获到异常，那么就清除缓存中bean名称对应的bean实例
destroySingleton(beanName);
throw ex;
}
}
});
// 获取给定Bean的实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 获取一个注册成功的单例对象
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' 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 the 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 recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
singletonObject = singletonFactory.getObject();
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
addSingleton(beanName, singletonObject);
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
核心实现设置一级缓存singletonObjects的addSingleton方法：
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
循环依赖的流程
- 先通过createBeanInstance方法实例化beanC，然后提前曝光，将beanC曝光到singletonFactories缓存中。获取属性beanD，发现beanD未实例化，然后使用getBean方法实例化属性beanD。
- beanD实例化过程中，依赖属singletonObjects性beanC，通过getSingleton方法获取，singletonObjects和earlySingletonObjects缓存都没有，但是singletonFactories缓存由于之前的曝光，存在beanC，那么getObject方法直接拿到beanC，并且缓存到earlySingletonObjects中，最后在addSingleton方法缓存到singletonObjects，清空singletonFactories、earlySingletonObjects缓存，beanD实例化完毕。
- beanC将拿到实例化属性beanD，那么将执行populateBean方法完成属性值注入，将自身beanC通过ddSingleton方法缓存到singletonObjects中。
