Spring - 如何解决循环依赖

一、什么是循环依赖？

循环依赖是指在多个对象之间，存在相互依赖的关系，导致无法满足依赖关系的注入要求。具体来说，当两个或多个 bean 在 Spring 容器中互相依赖时，Spring 需要以某种方式打破这种依赖链，以避免死锁或初始化失败。

二、Spring解决循环依赖是有前置条件的

1. 出现循环依赖的Bean必须要是单例

2. 依赖注入的方式不能全是构造器注入的方式

为了测试循环依赖的解决情况跟注入方式的关系，我们做如下四种情况的测试，如下图：

三、解决循环依赖的具体流程

以AB相互依赖为例：

Spring在创建Bean的时候默认是按照自然排序来进行创建的，所以第一步Spring会去创建A。

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

1）实例化

对应方法：AbstractAutowireCapableBeanFactory中的createBeanInstance方法

作用：简单理解就是new了一个对象，为Bean分配内存空间。

2）属性注入

对应方法：AbstractAutowireCapableBeanFactory的populateBean方法

作用：为实例化中new出来的对象填充属性。也就是将当前类依赖的Bean属性，进行注入和装配。

3）初始化

对应方法：AbstractAutowireCapableBeanFactory的initializeBean

作用：执行aware接口中的方法，初始化方法，完成AOP代理。

基于上面的知识，我们开始解读整个循环依赖处理的过程，整个流程应该是以A的创建为起点。如下图：

创建A的过程实际上就是调用getBean方法，这个方法有两层含义：

创建一个新的Bean
从缓存中获取到已经被创建的对象

AbstractBeanFactory#getBean方法，部分源码如下：

public Object doGetBean(final String beanName, final boolean onlyEagerlyCached) {
   // 先从缓存中查找 Bean
    Object bean = getSingleton(beanName); 
    if (sharedInstance != null && args == null) {
       //...
    } else {
      // 如果缓存中没有，进行 Bean 的创建过程
    }
    return (T) bean;
}

1. 调用getSingleton(beanName)

首先调用getSingleton(beanName)方法，这个方法又会调用getSingleton(beanName, true)

DefaultSingletonBeanRegistry#getSingleton(getSingleton)

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

getSingleton(beanName, true)这个方法实际上就是到缓存中尝试去获取Bean，整个缓存分为三级

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    // 一级缓存，存储的是所有创建好了的单例Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    //提前暴露的一个单例工厂，二级缓存中存储的就是从这个工厂中获取到的对象
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    // 完成实例化，但是还未进行属性注入及初始化的对象
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
}

因为A是第一次被创建，所以不管哪个缓存中必然都是没有的，因此会进入getSingleton的另外一个重载方法getSingleton(beanName, singletonFactory)。

2. 调用getSingleton(beanName, singletonFactory)

这个方法就是用来创建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             // ....
 8             // 省略异常处理及日志
 9             // ....
10 
11             // 在单例对象创建前先做一个标记
12             // 将beanName放入到singletonsCurrentlyInCreation这个集合中
13             // 标志着这个单例Bean正在创建
14             // 如果同一个单例Bean多次被创建，这里会抛出异常
15             beforeSingletonCreation(beanName);
16             boolean newSingleton = false;
17             boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
18             if (recordSuppressedExceptions) {
19                 this.suppressedExceptions = new LinkedHashSet<>();
20             }
21             try {
22                 // 上游传入的lambda在这里会被执行，调用createBean方法创建一个Bean后返回
23                 singletonObject = singletonFactory.getObject();
24                 newSingleton = true;
25             }
26             // ...
27             // 省略catch异常处理
28             // ...
29             finally {
30                 if (recordSuppressedExceptions) {
31                     this.suppressedExceptions = null;
32                 }
33                 // 创建完成后将对应的beanName从singletonsCurrentlyInCreation移除
34                 afterSingletonCreation(beanName);
35             }
36             if (newSingleton) {
37                 // 添加到一级缓存singletonObjects中
38                 addSingleton(beanName, singletonObject);
39             }
40         }
41         return singletonObject;
42     }
43 }

上面的代码我们主要抓住一点，通过createBean方法返回的Bean最终被放到了一级缓存，也就是单例池中。

那么到这里我们可以得出一个结论：一级缓存中存储的是已经完全创建好了的单例Bean。

3. 调用addSingletonFactory方法

先看下AbstractAutowireCapableBeanFactory#doCreateBean方法：

 1 protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
 2             throws BeanCreationException {
 3 
 4         //...
 5         if (instanceWrapper == null) {
 6             instanceWrapper = createBeanInstance(beanName, mbd, args);
 7         }
 8 
 9         //前面已经完成了createBeanlnstance
10         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
11                 isSingletonCurrentlyInCreation(beanName));
12         if (earlySingletonExposure) {
13             if (logger.isTraceEnabled()) {
14                 logger.trace("Eagerly caching bean '" + beanName +
15                         "' to allow for resolving potential circular references");
16             }
17             //添加到三级缓存中
18             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
19         }
20 
21         // Initialize the bean instance.
22         Object exposedObject = bean;
23         try {
24             //三级缓存添加后再开始属性注入
25             populateBean(beanName, mbd, instanceWrapper);
26             //初始化
27             exposedObject = initializeBean(beanName, exposedObject, mbd);
28         }
29 
30         return exposedObject;
31  }

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

 1 // 这里传入的参数也是一个lambda表达式，() -> getEarlyBeanReference(beanName, mbd, bean)
 2 protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
 3     Assert.notNull(singletonFactory, "Singleton factory must not be null");
 4     synchronized (this.singletonObjects) {
 5         if (!this.singletonObjects.containsKey(beanName)) {
 6             // 添加到三级缓存中
 7             this.singletonFactories.put(beanName, singletonFactory);
 8             this.earlySingletonObjects.remove(beanName);
 9             this.registeredSingletons.add(beanName);
10         }
11     }
12 }

这里只是添加了一个工厂，通过这个工厂（ObjectFactory）的getObject方法可以得到一个对象，而这个对象实际上就是通过getEarlyBeanReference这个方法创建的。那么，什么时候会去调用这个工厂的getObject方法呢？这个时候就要到创建B的流程了。

当A完成了实例化并添加进了三级缓存后，就要开始为A进行属性注入了，在注入时发现A依赖了B，那么这个时候Spring又会去getBean(b)，然后反射调用setter方法完成属性注入。

如下图：

因为B需要注入A，所以在创建B的时候，又会去调用getBean(a)，这个时候就又回到之前的流程了，但是不同的是，之前的getBean是为了创建Bean，而此时再调用getBean不是为了创建了，而是要从缓存中获取，因为之前A在实例化后已经将其放入了三级缓存singletonFactories中，所以此时getBean(a)的流程就是这样子了，如下图：

从这里我们可以看出，注入到B中的A是通过getEarlyBeanReference方法提前暴露出去的一个对象，还不是一个完整的Bean，那么getEarlyBeanReference到底干了啥了，我们接着往下看。

4. getEarlyBeanReference方法

AbstractAutowireCapableBeanFactory#getEarlyBeanReference方法：

 1     protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
 2         Object exposedObject = bean;
 3         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
 4             for (BeanPostProcessor bp : getBeanPostProcessors()) {
 5                 if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
 6                     SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
 7                     exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
 8                 }
 9             }
10         }
11         return exposedObject;
12     }

其中，SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference 方法：

    default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return bean;
    }

它实际上就是调用了后置处理器的getEarlyBeanReference，而真正实现了这个方法的后置处理器只有一个，就是通过@EnableAspectJAutoProxy注解导入的AnnotationAwareAspectJAutoProxyCreator。

如果 bean 需要被 AOP 代理(比如@Transactional)，getEarlyBeanReference 会返回一个代理对象，而不是原始的 bean 实例。如果不考虑AOP的情况下，这个工厂啥都没干，直接将实例化阶段创建的对象返回了。

代理的提前暴露：

getEarlyBeanReference() 方法会确保当 bean 被创建时，如果需要 AOP 代理，Spring 会在它完全初始化之前就将代理对象暴露出来。这样其他依赖于这个 bean 的对象就可以引用这个代理对象，而不是等待整个 bean 完全初始化。

4. 创建A的整个流程

这个时候我们需要将整个创建A这个Bean的流程走完，如下图：

从上图中我们可以看到，虽然在创建B时会提前给B注入了一个还未初始化的A对象，但是在创建A的流程中一直使用的是注入到B中的A对象的引用，之后会根据这个引用对A进行初始化，所以B中提前注入了一个没有经过初始化的A类型对象是没有问题的。

5. 结合了AOP的循环依赖

如果在开启AOP的情况下，那么就是调用到AnnotationAwareAspectJAutoProxyCreator从父类AbstractAutoProxyCreator继承而来的getEarlyBeanReference方法，对应的源码如下：

AbstractAutoProxyCreator#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的实例化阶段创建后的对象。如下图：

这里有两个问题要注意：

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

AbstractAutowireCapableBeanFactory#doCreateBean方法中：

在完成初始化后，Spring又调用了一次getSingleton方法，这一次传入的参数又不一样了，false可以理解为禁用三级缓存，前面图中已经提到过了，在为B中注入A时已经将三级缓存中的工厂取出，并从工厂中获取到了一个对象放入到了二级缓存中，所以这里的这个getSingleton方法做的事情就是从二级缓存中获取到这个代理后的A对象。exposedObject == bean可以认为是必定成立的，除非你非要在初始化阶段的后置处理器中替换掉正常流程中的Bean。但是不建议这样去做。

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

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

6. addSingleton

初始化完成之后的操作

DefaultSingletonBeanRegistry#addSingleton方法

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) { // 锁定一级缓存，确保线程安全
        this.singletonObjects.put(beanName, singletonObject); // 将完全初始化的 bean 放入一级缓存
        this.singletonFactories.remove(beanName);    // 移除三级缓存中的工厂引用，因为不再需要创建代理或提前引用
        this.earlySingletonObjects.remove(beanName); // 移除二级缓存中的提前暴露的 bean 引用，避免重复
        this.registeredSingletons.add(beanName);     // 将 bean 名称加入已注册单例列表，用于后续管理
    }
}

三、总结

1. 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再完成它的整个生命周期。至此，循环依赖结束！

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

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

参考链接：

https://developer.aliyun.com/article/766880

posted @ 2024-11-10 16:34 欢乐豆123 阅读(6) 评论(0) 编辑收藏举报

刷新页面返回顶部

欢乐豆123

Spring - 如何解决循环依赖

Spring - 如何解决循环依赖

公告