Java Spring

一、什么是循环依赖

就是有两个服务，A服务，B服务，然后在A里注入了B，然后在B里注入了A，这就是循环依赖了，这种情况如果不解决的话，那就会出现一个相互依赖注入的死循环。

二、循环依赖的解决方案 - 三级缓存

2.1 什么是三级缓存

  1. /** 一级缓存 单例缓存池 用于保存我们所有的单实例bean */
  2. private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  4. /** 二级缓存 保存半成品bean实例，当对象需要被AOP切面代时，保存代理bean的实例beanProxy*/
  5. private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
  7. /** 三级缓存 存放ObjectFactory，传入的是匿名内部类，ObjectFactory.getObject() 方法最终会
  8.       调用getEarlyBeanReference()进行处理，返回创建bean实例化的lambda表达式。*/
  9. private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

2.2 三级缓存如何解决循环依赖的问题

前置知识：Spring的单例对象的初始化主要分为三步：
（1）createBeanInstance：实例化，其实也就是调用对象的构造方法实例化对象
（2）populateBean：填充属性，这一步主要是多bean的依赖属性进行填充
（3）initializeBean：调用spring xml中的init 方法。

2.2.1 重点方法

循环依赖涉及的重点方法是DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)

  1. //一个纯bean获取流程，这里不进行创建
  2. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  3.     // 从一级缓存singletonObjects获取bean
  4.     Object singletonObject = this.singletonObjects.get(beanName);
  5.     // 一级缓存没有，判断该bean是否在创建中，通过Set的contains来判断
  6.     if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  7.         synchronized (this.singletonObjects) {
  8.             // 从二级缓存中获取bean
  9.             singletonObject = this.earlySingletonObjects.get(beanName);
  10.             // 二级缓存没有&&允许提前引用
  11.             if (singletonObject == null && allowEarlyReference) {
  12.                 // 从三级缓存中获取lambda表达式
  13.                 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  14.                // 如果获取到该lambda表达式，进行回调填充
  15.                 if (singletonFactory != null) {
  16.                     // 调用三级缓存的lambda表示获取早期不完整对象
  17.                     singletonObject = singletonFactory.getObject();
  18.                     // 写入二级缓存
  19.                     this.earlySingletonObjects.put(beanName, singletonObject);
  20.                     // 三级缓存移除该bean的lambda表达式
  21.                     this.singletonFactories.remove(beanName);
  22.                 }
  23.             }
  24.         }
  25.     }
  26.     return singletonObject;
  27. }
  29. public boolean isSingletonCurrentlyInCreation(String beanName) {
  30.     return this.singletonsCurrentlyInCreation.contains(beanName);
  31. }

2.2.2 提前透知下AB存在循环依赖的情况大概是怎样一个加载流程，源码解读放下面

现在来分析一下A B循环依赖的情况

  • A doCreateBean()实例化，由于还未创建，从一级缓存查不到，且不是正在创建，这时候调用bean创建流程，将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存singletonFactories;
  • A populateBean()进行属性注入时候发现自己需要B对象，但是三级缓存中未发现B，就去创建B同样把创建B bean的lambda表达式放入singletonFactories;
  • B populateBean() 发现自己需要A对象，从一级缓存singletonObjects和二级缓存earlySingletonObjects中未发现A，但是在三级缓存singletonFactories中发现A，执行singletonFactories 里A的回调函数getEarlyBeanReference(),创建不完整的A bean，将其放入二级缓存earlySingletonObjects，同时从三级缓存删除；
  • 将A注入到对象B中，B完成属性填充，执行初始化方法，将自己放入第一级缓存中（此时B是一个完整的对象）；
  • 返回，A得到对象B，将B注入到A中，A完成属性填充，初始化，并放入到一级缓存中。

  • 在创建过程中，都是从三级缓存(对象工厂里创建不完整对象)，将提前暴露的对象放入到二级缓存，从二级缓存拿到后，完成初始化，放入一级缓存。

    三、原码分析

    Spring如何解决循环依赖的源码分析 - 图1

    3.1. BeanServiceA的创建:

    在创建bean时，会调用doGetBean方法，首先通过getSingleton方法从缓存中看是否能获取到该bean

  • a. 先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中，显然初次创建时不成立，即getSingleton返回null

  • b. 调用第14行的getSingleton方法触发createBean回调，进行bean的生命周期 ```java protected T doGetBean(
    1.       String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    2.       throws BeansException {
    3.   ... ... ...
    4.   //先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中，显然初次创建时不成立，即getSingleton返回null
    5.   Object sharedInstance = getSingleton(beanName);
    6.   if (sharedInstance != null && args == null) {
    7.       ... ... ... 
    8.   }else {
    9.       ... ... ...
    10.       try {
    11.           ... ... ...
    12.           if (mbd.isSingleton()) {
    13.               //getSingleton方法触发createBean回调，进行bean的生命周期  
    14.               //这里会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
    15.               sharedInstance = getSingleton(beanName, () -> {
    16.                   try {
    17.                       return createBean(beanName, mbd, args);
    18.                   }
    19.       ... ... ...
    20.   }
    21.   return (T) 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正在创建 beforeSingletonCreation(beanName); … … … try { // lambda表达式回到createBean singletonObject = singletonFactory.getObject(); newSingleton = true; } … … … } return singletonObject; } }

  1. <a name="VIaYG"></a>
  2. #### 3.1.1. 实例化BeanServiceA不完整对象:
  4. - 一般通过`createBeanInstancec`实例化不完整的`BeanServiceA`对象
  5. - 将不完整对象以及`BeanDefinition`代表的lambda表达式写入三级缓存
  6. - 属性填充BeanServiceB
  7. - 初始化BeanServiceA时调用AOP后置处理器进行AOP处理
  8. - 处理提前暴露的场景，保证返回同一个代理对象
  9. ```java
  10. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  11.         throws BeanCreationException {
  13.     ... ... ...
  14.     if (instanceWrapper == null) {
  15.         // a. 一般通过createBeanInstancec实例化不完整的BeanServiceA对象
  16.         instanceWrapper = createBeanInstance(beanName, mbd, args);
  17.     }
  18.     ... ... ...
  19.     // 默认单例&&默认循环引用&&该bean正在创建，条件成立
  20.     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  21.             isSingletonCurrentlyInCreation(beanName));
  22.     if (earlySingletonExposure) {
  23.         ... ... ...
  24.         // b. 将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
  25.         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  26.     }
  28.     // Initialize the bean instance.
  29.     Object exposedObject = bean;
  30.     try {
  31.         // c. 属性填充BeanServiceB
  32.         populateBean(beanName, mbd, instanceWrapper);
  33.         // d.初始化时调用AOP后置处理器进行AOP处理
  34.         exposedObject = initializeBean(beanName, exposedObject, mbd);
  35.     }
  36.     ... ... ...
  37.     // e.处理提前暴露的场景，保证返回同一个代理对象
  38.     if (earlySingletonExposure) {
  39.         // 见上文第1节的节速，由于第二个参数是false，所以只会查到第二季缓存
  40.         // 所以这里就是查看第二级缓存能不能取到值，取到就意味着涉及提前AOP
  41.         Object earlySingletonReference = getSingleton(beanName, false);
  42.         // 涉及提前AOP，从二级缓存中获取提前AOP的代理对象
  43.         if (earlySingletonReference != null) {
  44.             if (exposedObject == bean) {
  45.                 // 保证循环依赖且涉及AOP时，返回同一个代理对象，下文有结束
  46.                 exposedObject = earlySingletonReference;
  47.             }
  48.             ... ... ...
  49.         }
  50.     }
  51.     return exposedObject;
  52. }

上面 addSingletonFactory将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存

  1. protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  2.     Assert.notNull(singletonFactory, "Singleton factory must not be null");
  3.     synchronized (this.singletonObjects) {
  4.         if (!this.singletonObjects.containsKey(beanName)) {
  5.             // 将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
  6.             this.singletonFactories.put(beanName, singletonFactory);
  7.             this.earlySingletonObjects.remove(beanName);
  8.             this.registeredSingletons.add(beanName);
  9.         }
  10.     }
  11. }

3.1.2. 属性填充BeanServiceB:

关于属性填充方法的详细介绍可参考链接：属性填充populateBean
当填充BeanServiceB会重复上文第1节中的内容：

  • a. 先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中，显然初次创建时不成立，即getSingleton返回null
  • b. 调用第14行的getSingleton方法触发createBean回调，进行bean的生命周期
  • c. 实例化BeanServiceB的不完整对象，并将lambda写入三级缓存
  • d. 属性填充BeanServiceA（见下文1.1.2.1）

  • e. initializeBean初始化BeanServiceB

    3.1.2.1. 上面的d，循环依赖处理属性填充BeanServiceA:

    同样，会重复上文第1节的内容，但此时会有不一样的处理：

  • a. 先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中,显然正在创建，singletonsCurrentlyInCreation有beanServiceA

  • b. 从二级缓存中获取 → 获取不到 → 从三级缓存获取 → lambda表达式回调（见下文1.1.2.1.1）
  • c. 将不完整对象BeanServiceA写入二级缓存，三级缓存删除该对象lambda表达式（上文1中getSingleton方法）

  • d. 返回不完整的BeanServiceA对象

    3.1.1.2.1.1. AbstractAutoProxyCreator#getEarlyBeanReference:

    这里涉及Aop

    1. protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    2.   Object exposedObject = bean;
    3.   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    4.       //遍历后置处理器
    5.       for (BeanPostProcessor bp : getBeanPostProcessors()) {
    6.           if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
    7.               SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
    8.               // 调用后置处理器的getEarlyBeanReference进行提前暴露bean
    9.               exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
    10.           }
    11.       }
    12.   }
    13.   return exposedObject;
    14. }

    lambda回调会调用后置处理器的getEarlyBeanReference，来获取不完整的bean

  • 如果当前依赖的bean不涉及Aop，则返回实例化时创建的不完整bean对象

  • 如果当前依赖的bean涉及Aop，则返回一个代理该不完整bean的代理对象

  • 本处返回实例化创建的不完整beanServiceA对象

    1. public Object getEarlyBeanReference(Object bean, String beanName) {
    2.   Object cacheKey = getCacheKey(bean.getClass(), beanName);
    3.   // 写入earlyProxyReferences，在后面postProcessAfterInitialization会用到
    4.   this.earlyProxyReferences.put(cacheKey, bean);
    5.   // 判断是否创建代理对象
    6.   return wrapIfNecessary(bean, beanName, cacheKey);
    7. }

    3.1.2.2 初始化BeanServiceB时调用AOP后置处理器进行AOP处理

    属性填充beanServiceA后，此时填充的beanServiceA是不完整的对象,
    在initializeBean初始化调用后置处理器的postProcessAfterInitialization方法
    image.png
    由于BeanServiceB不涉及AOP，所以返回原始的B对象，此时填充的beanServiceA还是不完整的对象

  • B不涉及提前AOP，所以earlyProxyReferences没有beanServiceB（见上文3.1.2.1.1）

  • remove返回null，条件成立，执行wrapIfNecessary方法

  • 由于beanServiceB不涉及AOP，所以返回原始的B对象

    3.1.2.3. 处理提前暴露的场景，保证返回同一个代理对象

    BeanServiceB不涉及AOP，getSingleton返回null，所以直接返回原始对象exposedObject
    Spring如何解决循环依赖的源码分析 - 图3

    3.1.2.4. BeanServiceB对象写入一级缓存，移除二、三级缓存

    beanServiceB生命周期执行完，返回到3.1节第14行的getSingleton方法，此时返回的还是不完整的beanServiceB对象
    singletonsCurrentlyInCreation移除bean，表明不再是正在创建的bean

    1. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    2.   Assert.notNull(beanName, "Bean name must not be null");
    3.   synchronized (this.singletonObjects) {
    4.       Object singletonObject = this.singletonObjects.get(beanName);
    5.       if (singletonObject == null) {
    6.           ... ... ...
    7.               // 会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
    8.               beforeSingletonCreation(beanName);
    9.           ... ... ...
    10.               try {
    11.                   // lambda表达式回到createBean
    12.                   singletonObject = singletonFactory.getObject();
    13.                   newSingleton = true;
    14.                   ... ... ..
    15.                   }
    16.           finally {
    17.               if (recordSuppressedExceptions) {
    18.                   this.suppressedExceptions = null;
    19.               }
    20.               // singletonsCurrentlyInCreation中移除beanName，表示该bean不是正在创建了
    21.               afterSingletonCreation(beanName);
    22.           }
    23.           if (newSingleton) {
    24.               // 将不完整的beanServiceB对象写入一级缓存，移除二、三级缓存
    25.               addSingleton(beanName, singletonObject);
    26.           }
    27.       }
    28.       return singletonObject;
    29.   }
    30. }

    beanServiceB“不完整对象”写入一级缓存，移除二、三级缓存

    1. protected void addSingleton(String beanName, Object singletonObject) {
    2.   synchronized (this.singletonObjects) {
    3.       // 写入一级缓存
    4.       this.singletonObjects.put(beanName, singletonObject);
    5.       // 移除二、三级缓存
    6.       this.singletonFactories.remove(beanName);
    7.       this.earlySingletonObjects.remove(beanName);
    8.       this.registeredSingletons.add(beanName);
    9.   }
    10. }

    3.1.3. BeanServiceA属性填充BeanServiceB（完整bean）

    此时ioc容器已经有了beanServiceB，虽然暂时还是不完整的，因为A还没填充初始化完
    当beanServiceA填充完beanServiceB后，使得互相循环依赖对方，此时二者都变成了完整的bean
    此时一级缓存的beanServiceB也由不完整的bean变成了完整的bean，因为是同一个地址
    A涉及AOP，所以循环依赖时，A会进行提前AOP，所以B中填充的是A的代理对象
    当A填充完B时，构成互相循环依赖对方

    3.1.4. 初始化BeanServiceA时调用AOP后置处理器进行AOP处理

    由于beanServiceA提前AOP了，所以所以earlyProxyReferences有beanServiceA（见上文3.1.2.1.1）
    remove返回原始的bean，即earlyProxyReferences对应的value，条件不成立，直接==返回原始bean ==

    3.1.5. 处理提前暴露的场景，保证返回同一个代理对象

    beanServiceA涉及提前AOP，getSingleton返回保存在二级缓存中提前AOP的代理对象A
    Spring如何解决循环依赖的源码分析 - 图4
    这里面有exposedObject == bean判断，这就是为什么上述3.1.4中AOP后置处理器返回原始bean的原因
    条件成立，将代理对象赋值放回，保证返回同一个代理对象，即B中的A和A都是同一个代理对象

    3.2. BeanServiceA完整对象写入一级缓存，移除二、三级缓存

    同3.1.2.4节一样，beanServiceA生命周期执行完，会将beanServiceA写入一级缓存，移除二、三级缓存

    四、整体流程

    4.1 涉及循环依赖&&涉及AOP的场景

    Spring如何解决循环依赖的源码分析 - 图5

    4.2 不涉及AOP的循环依赖场景

  • 不涉及AOP，那么A进行lambda表达式回调后返回就A的原始对象，保存到二级缓存中，所以B属性填充后的A也是A的原始对象

  • 当A属性填充完后，A和B相互依赖，使得二者都是完整的对象，可见上文3.1.3的图

    4.3 不涉及循环依赖的AOP场景

  • 不涉及循环依赖，也就不涉及提前AOP，正常A经过实例化–属性填充–初始化

  • 在初始化时通过AOP后置处理器创建代理对象返回，在上文1.1.5节，二级缓存返回null，最终直接返回代理对象A

    4.4 不涉及循环依赖&&不涉及AOP场景

  • 不涉及循环依赖，也就不涉及提前AOP，正常A经过实例化–属性填充–初始化

  • 不涉及AOP，则在初始化时通过AOP后置处理器直接返回原始A对象，在上文1.1.5节，二级缓存返回null，最终返回原始A对象

    五、疑问：

    5.1 为什么三级缓存用HashMap，而不像一级缓存使用ConcurrentHashMap

    现有逻辑是，三级缓存的操作是在synchronized代码块里面操作的，是安全的
    那为什么要用synchronized而不直接用ConcurrentHashMap来保证线程安全呢？
    二级缓存put的同时要保证三级缓存remove；三级缓存put时要保证二级缓存remove，也就是说二三级缓存操作要保证原子性
    因为要保证同一个bean是单例的，不然都会lambda回调创建bean，就不是单例的了
    如果使用ConcurrentHashMap并不能保证二三级缓存操作的原子性，所以要用synchronized
    这三级缓存都是在synchronized内操作的，至于一级缓存为什么用ConcurrentHashMap，可能其他场景的原因。

    5.2 什么要第三级缓存？

    主要用于循环依赖的bean需要AOP时提前AOP
    如果没有第三级缓存，那么getSingleton就返回null，就会再次传教A，导致一直循环创建，现有逻辑就不对.
    Spring如何解决循环依赖的源码分析 - 图6
    那如果将实例化的原始对象放入二级缓存呢？
    没有第三级缓存，就无法提前AOP，则B属性填充完的A为A原始对象
    而A在属性填充完B后，需要进行AOP，则经过AOP后置处理器会去创建代理对象A返回
    这就导致B的属性A不是代理对象，而A却是代理对象，这与Spring的单例bean是矛盾的。

    5.3代码里如果出现了循环依赖怎么处理比较好？

  1. 使用@Lazy注解，延迟加载
  2. 使用@DependsOn注解，指定加载先后关系
  3. 修改文件名称，改变循环依赖类的加载顺序