Spring源码解析(五)：循环依赖

Spring源码系列文章

Spring源码解析(一)：环境搭建

Spring源码解析(二)：bean容器的创建、默认后置处理器、扫描包路径bean

Spring源码解析(三)：bean容器的刷新

Spring源码解析(四)：单例bean的创建流程

Spring源码解析(五)：循环依赖

---

一、什么是循环依赖

• 简单点说，就是A依赖了B，B依赖的A

@Component
public class A {

	@Autowired
	private B b;
}

@Component
public class B {

	@Autowired
	private A a;
}

• 如果不处理，那么A创建时候需要属性填充B
• 此时B还没有创建，那么去创建B，又需要属性填充A
• 以此形成了死循环

二、什么情况下循环依赖可以被处理？

依赖情况	依赖注入方式	循环依赖是否被解决
AB相互依赖（循环依赖）	均采用setter方法注入	是
AB相互依赖（循环依赖）	均采用构造器注入	否
AB相互依赖（循环依赖）	A中注入B的方式为setter方法，B中注入A的方式为构造器	是
AB相互依赖（循环依赖）	B中注入A的方式为setter方法，A中注入B的方式为构造器	否

三、简单的循环依赖（没有AOP）

Spring在创建Bean的过程中分为三步

1. 实例化，简单理解就是new一个对象
2. 属性注入，为实例化对象属性赋值
3. 初始化，执行aware接口中的方法，初始化方法，完成AOP代理

以上面AB相互依赖为例

@Component
public class A {

	@Autowired
	private B b;
}

@Component
public class B {

	@Autowired
	private A a;
}

解读整个循环依赖处理的过程

• 整个流程应该是以A的创建为起点
• Spring在创建Bean的时候默认是按照自然排序来进行创建的，所以第一步Spring会去创建A
• 创建A的过程实际上就是调用getBean方法，这个方法有两层含义
  1. 创建一个新的Bean
  2. 从缓存中获取到已经被创建的对象

1、getSingleton(beanName)缓存中获取对象

• 调用getSingleton(a)方法，这个方法又会调用getSingleton(beanName, true)
• true表示允许提前曝光引用

public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}

• getSingleton(beanName, true)这个方法实际上就是到缓存中尝试去获取Bean，整个缓存分为三级
  • singletonObjects，一级缓存，存储的是所有创建好了的单例Bean
  • earlySingletonObjects，完成实例化，但是还未进行属性注入及初始化的对象
  • singletonFactories，提前暴露的一个单例工厂，二级缓存中存储的就是从这个工厂中获取到的对象

• if中代码不会执行，因为还没有到bean的创建中，这是创建前的操作
• 因为A是第一次被创建，所以不管哪个缓存中必然都是没有的
• 因此会进入getSingleton的另外一个重载方法getSingleton(beanName, singletonFactory)

2、getSingleton(beanName, singletonFactory)从对象工厂中获取对象，添加到一级缓存

• 核心代码：通过createBean方法返回的Bean最终被放到了一级缓存，也就是单例池中

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) {

            // ....
            // 省略异常处理及日志
            // ....

            // 在单例对象创建前先做一个标记
            // 将beanName放入到singletonsCurrentlyInCreation这个集合中
            // 标志着这个单例Bean正在创建
            // 如果同一个单例Bean多次被创建，这里会抛出异常
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
			
			// ....
            // 用于记录异常相关信息
            // ....

            try {
                // 上游传入的lambda在这里会被执行，调用createBean方法创建一个Bean后返回
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            
            // ...
            // 省略catch异常处理
            // ...
            
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                // 创建完成后将对应的beanName从singletonsCurrentlyInCreation移除
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 添加到一级缓存singletonObjects中
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

• 将从对象工厂中获取的对象放入一级缓存
• 将creatBean中放入二三缓存的东西删除到，因为以后不需要了

3、addSingletonFactory(beanName, singletonFactory) 创建对象工厂添加到三级缓存

• 这段代码是creatBean中的核心内容
• 也就是bean真正的创建

在完成Bean的实例化后，属性注入之前Spring将Bean包装成一个工厂对象添加进了三级缓存中，对应源码如下：

• 这里只是添加了一个工厂，通过这个工厂（ObjectFactory）的getObject方法可以得到一个bean对象
• 而这个对象实际上就是通过getEarlyBeanReference这个方法创建的

4、getEarlyBeanReference()对象工厂暴露的对象引用

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

• 它实际上就是调用了后置处理器的getEarlyBeanReference
• 而真正实现了这个方法的后置处理器只有一个，就是通过@EnableAspectJAutoProxy注解导入的AnnotationAwareAspectJAutoProxyCreator
• 也就是说如果在不考虑AOP的情况下，上面的代码等价于：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    return exposedObject;
}

• 也就是说（不考虑AOP情况下）这个对象工厂啥都没干，直接将实例化阶段创建的对象返回了

总结

根据流程图串一下流程：

A依赖B，B依赖A，自然排序，所以先实例化A

1. getBean(a)，先从缓存中获取，没有，则需要去创建
2. 实例化A，创建一个对象工厂，可以通过getObje返回刚实例化的A对象，将对象工厂放入三级缓存
3. A属性填充，需要给A中的b属性赋值，则需要getBean(b)，先从缓存中获取，没有，则需要去创建
4. 实例化B，创建一个对象工厂，可以通过getObje返回刚实例化的A对象，将对象工厂放入三级缓存
5. B属性填充，需要给B中的a属性赋值，则需要getBean(a)，从缓存中获取getSingleton(beanName, true)
   • 此时a对象在创建中，所以会进入if方法
   • 一级缓存中没有，则去二级缓存中找，也没有
   • 最后从三级缓存获取对象工厂里的对象，放入二级缓存，并删除三级缓存的对象工厂
6. B属性填充完毕后，初始化，然后B对象的创建流程完毕
7. 接下来回到A的b属性填充，也就完成了
8. A初始化，创建流程完毕，删除A的二级缓存，放入一级缓存

四、aop代理bean的循环依赖

• 在普通的循环依赖的情况下，三级缓存没有任何作用
• 三级缓存实际上跟Spring中的AOP相关，我们再来看一看getEarlyBeanReference的代码：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

• 如果在开启AOP的情况下，那么就是调用到AnnotationAwareAspectJAutoProxyCreator的getEarlyBeanReference方法
• 对应的源码如下：

public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    this.earlyProxyReferences.put(cacheKey, bean);
    // 如果需要代理，返回一个代理对象，不需要代理，直接返回当前传入的这个bean对象
    return wrapIfNecessary(bean, beanName, cacheKey);
}

• 回到上面的例子，如果我们对A进行了AOP代理的话
• 那么此时getEarlyBeanReference将返回一个代理后的对象
• 而不是实例化阶段创建的对象
• 这样就意味着B中注入的A将是一个代理对象而不是A的实例化阶段创建后的对象

代理bean的循环依赖过程

1、在给B注入的时候为什么要注入一个代理对象？

• 当我们对A进行了AOP代理时
• 说明我们希望从容器中获取到的就是A代理后的对象而不是A本身
• 因此把A当作依赖进行注入时也要注入它的代理对象

2、明明初始化的时候是A对象，那么Spring是在哪里将代理对象放入到容器中的呢？

• 首先A对象创建，然后将A代理对象工厂放入三级缓存
• 然后A执行到下图populateBean()属性填充时候去创建B
• B属性填充的时候从三级缓存获取到代理对象，并放入二级缓存，并删除三级缓存
• B属性填充A的代理对象，然后初始化，B创建完毕，A属性赋值B也就完成了
• 接下来就是A的初始化，此时exposedObject还是A的原始对象
• 最后从二级缓存中拿到代理对象，之后会添加到一级缓存，并删除二级缓存

3、初始化的时候是对A对象本身进行初始化，而容器中以及注入到B中的都是代理对象，这样不会有问题吗？

• 不会
• 因为不管是cglib代理还是jdk动态代理生成的代理类，内部都持有一个目标类的引用
• 当调用代理对象的方法时，实际会去调用目标对象的方法，A完成初始化相当于代理对象自身也完成了初始化

4、三级缓存为什么要使用工厂而不是直接使用引用？换而言之，为什么需要这个三级缓存，直接通过二级缓存暴露一个引用不行吗？

• 这个工厂的目的在于延迟对实例化阶段生成的对象的代理
• 只有真正发生循环依赖的时候，才去提前生成代理对象
• 否则只会创建一个工厂并将其放入到三级缓存中，但是不会去通过这个工厂去真正创建对象

---

我们思考一种简单的情况，就以单独创建A为例，假设AB之间现在没有依赖关系，但是A被代理了，这个时候当A完成实例化后还是会进入下面这段代码：

// A是单例的，mbd.isSingleton()条件满足
// allowCircularReferences：这个变量代表是否允许循环依赖，默认是开启的，条件也满足
// isSingletonCurrentlyInCreation：正在在创建A，也满足
// 所以earlySingletonExposure=true
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                  isSingletonCurrentlyInCreation(beanName));
// 还是会进入到这段代码中
if (earlySingletonExposure) {
	// 还是会通过三级缓存提前暴露一个工厂对象
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

• 即使没有循环依赖，也会将其添加到三级缓存中，而且是不得不添加到三级缓存中
• 因为到目前为止Spring也不能确定这个Bean有没有跟别的Bean出现循环依赖

---

• 假设我们在这里直接使用二级缓存的话，那么意味着所有的Bean在这一步都要完成AOP代理
• Spring结合AOP跟Bean的生命周期本身就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来完成的，在这个后置处理的postProcessAfterInitialization方法中对初始化后的Bean完成AOP代理
  • 如果出现了循环依赖，那没有办法，只有给Bean先创建代理
  • 但是没有出现循环依赖的情况下，设计之初就是让Bean在生命周期的最后一步完成代理而不是在实例化后就立马完成代理
  • 如果没有循环依赖，只是三级缓存添加了一个代理A对象工厂（不会执行），A对象会在初始化最后一步生成代理对象，然后放入一级缓存，最后清空二三级缓存

五、总结

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

• Spring通过三级缓存解决了循环依赖，其中一级缓存为单例池（singletonObjects）,二级缓存为早期曝光对象（earlySingletonObjects)，三级缓存为早期曝光对象工厂（singletonFactories）
• 当A、B两个类发生循环引用时，在A完成实例化后，就使用实例化后的对象去创建一个对象工厂，并添加到三级缓存中
  • 如果A被AOP代理，那么通过这个工厂获取到的就是A代理后的对象
  • 如果A没有被AOP代理，那么这个工厂获取到的就是A实例化的对象
• 当A进行属性注入时，会去创建B，同时B又依赖了A，所以创建B的同时又会去调用getBean(a)来获取需要的依赖，此时的getBean(a)会从缓存中获取
  • 第一步，先获取到三级缓存中的对象工厂
  • 第二步，调用对象工工厂的getObject方法来获取到对应的对象，得到这个对象后将其注入到B中
  • 紧接着B会走完它的生命周期流程，包括初始化、后置处理器等
• 当B创建完后，会将B再注入到A中，此时A再完成它的整个生命周期
• 至此，循环依赖结束！

为什么要使用三级缓存呢？二级缓存能解决循环依赖吗？

• 如果要使用二级缓存解决循环依赖，意味着所有Bean在实例化后就要完成AOP代理，这样违背了Spring设计的原则
• Spring在设计之初就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来在Bean生命周期的最后一步来完成AOP代理，而不是在实例化后就立马进行AOP代理