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

Posted 2023-03-28

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring是如何解决循环依赖的？相关的知识，希望对你有一定的参考价值。

参考技术A

你需要我，我需要你就是循环依赖

在Spring中使用的三级缓存来解决循环依赖问题，这里的缓存其实就是Map对象

当获取一个Bean时会先从缓存中查找是否有相应的Bean。

1 创建A实例

2 将A实例（半初始化，属性没有填充）暴露放入缓存中

3 填充A实例的属性

4 A实例属性依赖B对象

5 创建B对象实例

6 填充B实例属性

7 B实例属性依赖A对象

8 将上面已经暴露到三级缓存中的A对象注入给B实例

在获取A对象的时候执行上面27.1中的getSingleton方法，会将三级缓存中A这个半初始化状态的对象移除，将其存入到二级缓存中。

9 B实例Bean的创建工作继续执行初始化方法

B如果需要AOP代理？最终B对象是个代理对象。B到此就完全的初始化完了，B的依赖对象A此时是个半初始化状态的对象

10 B实例对象保存到一级缓存

最终B实例创建，初始化都执行完后会将自身加入到一级缓存同时清除二级，三级缓存

11 A实例Bean创建继续执行

如果B是被AOP代理的那么此时的A实例注入的B对象就是一个代理对象。

12 A实例Bean执行初始化方法

13 A继续执行上面的10步骤

三级缓存解决问题：循环依赖+AOP问题

只用一，二级缓存：

从上面罗列的步骤看似乎很是完美解决了循环依赖问题，接下来我们看看加入AOP的场景

假如A，B两个对象最终都是要被AOP代理的

执行到这里，A中依赖的B是代理对象没有问题，但是B中依赖的A对象是原始对象；这就不正确了应该依赖的A也必须是代理对象才是。

引入三级缓存：

三级缓存引入了ObjectFactory对象，在获取对象的时候，是调用ObjectFactory#getObject方法。

而这个getObject方法的实现实际执行的是getEarlyBeanReference方法，再来回顾下：

在创建实例时先将其存入三级缓存中：

getEarlyBeanReference方法就是提前创建代理对象

如果开启了AOP代理后

通过getEarlyBeanReference方法提前创建代理对象。这样就解决了循环依赖时AOP代理问题。保证获取的都是同一个对象。

其实引入三级缓存还解决了一个问题就是延迟代理对象的创建，如果不应用ObjectFactory方式那么我们需要不管需不需要都要先创建代理对象，而引入ObjectFactory可以在注入的时候先暴露的是ObjectFactory只有在调用getObject方法的时候才去创建真正的代理对象（避免了所有Bean都强制创建代理对象）。当没有被代理时可以直接返回原始对象，如果被代理会提前创建代理对象。

不用二级直接是用一，三级缓存？

假设场景：A 依赖 B，B 依赖 A、C，C 依赖 A

如果这样会出现不同的代理对象，每次调用getObject都会创建不同的代理对象（在上面的场景中如果只用一，三级缓存那么 B 依赖 A会通过getObject获取一个代理对象Proxy$1，接着注入C的时候 C中又依赖A，那这时候又从getObject获取对象那么返回的将又会是一个新的代理对象Proxy$2；在这个过程中A对象就出现了2个不一样的对象了，这肯定是错误的）。而引入二级缓存也就解决了这个问题。只有二级缓存没有的时候才从三级缓存汇总获取（如果需要则创建代理对象，然后保存到二级缓存中，二级缓存中已经是提前创建了代理对象（如果需要代理））。

当一个Bean完全的创建完以后放入一级缓存中，此时会吧二级三级中的缓存清除。

完毕！！！！

SpringMVC参数统一验证方法
SpringBoot多数据源配置详解
SpringCloud Nacos 整合feign
Spring AOP动态代理失效的解决方法@Transactional为何会失效
SpringBoot配置文件你了解多少？
SpringBoot邮件发送示例 Springboot面试题整理附答案
SpringBoot项目查看线上日志
在Spring Cloud 中你还在使用Ribbon快来试试Load-Balancer
SpringBoot分库分表sharding-sphere3

Spring 是如何解决循环依赖的

1.什么是循环依赖?

2.通过手写代码助你理解Spring循环依赖:

为什么需要二级缓存？

为什么需要三级缓存？

为什么Spring不能解决构造器的循环依赖？

4.1 何时进行拓展？（进行bean的实例化时）

4.2 getEarlyBeanReference方法

附带一张循环依赖的总图：

1.什么是循环依赖?

所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。或者是 A 依赖 B，B 依赖 C，C 又依赖 A。它们之间的依赖关系如下：

2.通过手写代码助你理解Spring循环依赖:

DEMO:

/***
 * 
 * Spring --循环依赖实例DEMO  :
 * 帮助您更有效的理解Spring循环依赖源码
 */
public class MainStart {

    private static Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    /**
     * 读取bean定义，当然在spring中肯定是根据配置 动态扫描注册
     */
    public static void loadBeanDefinitions() {
        RootBeanDefinition aBeanDefinition=new RootBeanDefinition(InstanceA.class);
        RootBeanDefinition bBeanDefinition=new RootBeanDefinition(InstanceB.class);
        beanDefinitionMap.put("instanceA",aBeanDefinition);
        beanDefinitionMap.put("instanceB",bBeanDefinition);
    }

    public static void main(String[] args) throws Exception {
        // 加载了BeanDefinition
        loadBeanDefinitions();
        // 注册Bean的后置处理器

        // 循环创建Bean
        for (String key : beanDefinitionMap.keySet()){
            // 先创建A
            getBean(key);
        }
        InstanceA instanceA = (InstanceA) getBean("instanceA");
        instanceA.say();
    }

    // 一级缓存
    public static Map<String,Object> singletonObjects=new ConcurrentHashMap<>();


    // 二级缓存： 为了将 成熟Bean和纯净Bean分离，避免读取到不完整得Bean
    public static Map<String,Object> earlySingletonObjects=new ConcurrentHashMap<>();

    // 三级缓存
    public static Map<String,ObjectFactory> singletonFactories=new ConcurrentHashMap<>();

    // 循环依赖标识
    public  static  Set<String> singletonsCurrennlyInCreation=new HashSet<>();


    // 假设A 使用了Aop @PointCut("execution(* *..InstanceA.*(..))")   要给A创建动态代理
    // 获取Bean
    public  static Object getBean(String beanName) throws Exception {
        Object singleton = getSingleton(beanName);
        if(singleton!=null){
            return singleton;
        }

        // 正在创建
        if(!singletonsCurrennlyInCreation.contains(beanName)){
            singletonsCurrennlyInCreation.add(beanName);
        }
        // createBean


        // 实例化
        RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
        Class<?> beanClass = beanDefinition.getBeanClass();
        Object instanceBean = beanClass.newInstance();  // 通过无参构造函数

        // 创建动态代理  （耦合 、BeanPostProcessor)    Spring还是希望正常的Bean 还是再初始化后创建
        // 只在循环依赖的情况下在实例化后创建proxy   判断当前是不是循环依赖
        singletonFactories.put(beanName, () -> new JdkProxyBeanPostProcessor().getEarlyBeanReference(earlySingletonObjects.get(beanName),beanName));

        // 添加到二级缓存
        // earlySingletonObjects.put(beanName,instanceBean);

        // 属性赋值
        Field[] declaredFields = beanClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            Autowired annotation = declaredField.getAnnotation(Autowired.class);
            // 说明属性上面有Autowired
            if(annotation!=null){
                 declaredField.setAccessible(true);
                 // byname  bytype  byconstrator
                // instanceB
                String name = declaredField.getName();
                Object fileObject= getBean(name);   //拿到B得Bean
                declaredField.set(instanceBean,fileObject);
            }

        }


        // 初始化   init-mthod
        // 放在这里创建已经完了  B里面的A 不是proxy
        // 正常情况下会再 初始化之后创建proxy



        // 由于递归完后A 还是原实例，， 所以要从二级缓存中拿到proxy 。
        if(earlySingletonObjects.containsKey(beanName)){
            instanceBean=earlySingletonObjects.get(beanName);
        }

        // 添加到一级缓存   A
        singletonObjects.put(beanName,instanceBean);


        // remove 二级缓存和三级缓存
        return instanceBean;
    }


    public  static Object getSingleton(String beanName){
        // 先从一级缓存中拿
        Object bean = singletonObjects.get(beanName);

        // 说明是循环依赖
        if(bean==null && singletonsCurrennlyInCreation.contains(beanName)){
            bean=earlySingletonObjects.get(beanName);
            // 如果二级缓存没有就从三级缓存中拿
            if(bean==null) {
                // 从三级缓存中拿
                ObjectFactory factory = singletonFactories.get(beanName);
                if (factory != null) {
                    bean=factory.getObject(); // 拿到动态代理
                    earlySingletonObjects.put(beanName, bean);
                }
            }


        }

        return bean;

    }

}

下面观点完全由看完源码个人观点总结，如有雷同纯属英雄所见略同，如有误解欢迎讨论、

为什么需要二级缓存？

一级缓存和二级缓存相比：

二级缓存只要是为了分离成熟Bean和纯净Bean(未注入属性)的存放，防止多线程中在Bean还未创建完成时读取到的Bean时不完整的。所以也是为了保证我们getBean是完整最终的Bean，不会出现不完整的情况。

一二三级缓存下二级缓存的意义：

二级缓存为了存储三级缓存的创建出来的早期Bean，为了避免三级缓存重复执行。

为什么需要三级缓存？

我们都知道Bean的aop动态代理创建时在初始化之后，但是循环依赖的Bean如果使用了AOP。那无法等到解决完循环依赖再创建动态代理，因为这个时候已经注入属性。所以如果循环依赖的Bean使用了aop. 需要提前创建aop。

但是需要思考的是动态代理在哪创建？？在实例化后直接创建？但是我们正常的Bean是在初始化创建啊。所以可以加个判断如果是循环依赖就实例化后调用，没有循环依赖就正常在初始化后调用。

怎么判断当前创建的bean是不是循环依赖？根据二级缓存判断？有就是循环依赖？

那这个判断怎么加？加载实例化后面行吗？且看：

实例化后.省略code....

if(二级缓存有说明是循环依赖？){
        
 二级缓存=创建动态代理覆盖（判断当前bean是否被二级缓存命中）；
}

这样写可以吗？肯定不行啊，因为实例化后始终会放入二级缓存中。所以这样写不管是不是循环依赖都会在实例化后创建动态代理。

创建本身的时候没法判断自己是不是循环依赖，，只有在B 引用A （不同bean的引用直接）下才能判断是不是循环依赖（比如B引用A,A正在创建，那说明是循环依赖），所以判断要卸载getSingleton中。

假如A是proxy:
    
A创建Bean -->注入属性B-->getBean(B)-->创建B-->注入属性A---->getSingleton("a")之后写如下代码
==================================================================================================
public object getSingleton(beanName){
    先从一级缓存拿 省略code...

    if(二级缓存有说明是循环依赖？){  
         二级缓存=调用创建动态代BeanPostProcessor（判断是否使用aop，没有依然返回原实例）；
    }
}

在这里创建行吗？行！所以说二级缓存确实完全可以解决循环依赖的任何情况：包括扩展能力（因为也可以在这里调用BeanPostProcessor, 当然AOP也是基于BeanPostProcessor,虽然也当然可以解决）。

那要三级缓存干嘛？ 我们只能这样解释： Spring的方法职责都比较单例，一个方法通常只做一件事， getBean就是获取bean 但是调用创建动态代BeanPostProcessor 是属于create的过程中的，如果在这里明显代码比较耦合，阅读性也不太好。所以为了解耦、方法职责单一、方便后期维护，将调用创建动态代BeanPostProcessor 放在createBean中是最合适不过了，但是我们判断当前是否循环依赖还是要写在getSingleton里面啊，这怎么办：

三级缓存存一个函数接口，函数接口实现创建动态代理调用BeanPostProcessor 。为了避免重复创建，调用把返回的动态代理对象或者原实例存储在二级缓存，三个缓存完美解决解耦、扩展、性能、代码阅读性。

为什么Spring不能解决构造器的循环依赖？

从流程图应该不难看出来，在Bean调用构造器实例化之前，一二三级缓存并没有Bean的任何相关信息，在实例化之后才放入三级缓存中，因此当getBean的时候缓存并没有命中，这样就抛出了循环依赖的异常了。

为什么多例Bean不能解决循环依赖？

我们自己手写了解决循环依赖的代码，可以看到，核心是利用一个map，来解决这个问题的，这个map就相当于缓存。

为什么可以这么做，因为我们的bean是单例的，而且是字段注入（setter注入）的，单例意味着只需要创建一次对象，后面就可以从缓存中取出来，字段注入，意味着我们无需调用构造方法进行注入。

如果是原型bean，那么就意味着每次都要去创建对象，无法利用缓存；
如果是构造方法注入，那么就意味着需要调用构造方法注入，也无法利用缓存。

循环依赖可以关闭吗

可以，Spring提供了这个功能，我们需要这么写：

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.setAllowCircularReferences(false);
        applicationContext.register(AppConfig.class);
        applicationContext.refresh();
    }
}

3 源码：如何解决循环依赖？

3.1 哪三级缓存？

DefaultSingletonBeanRegistry类的三个成员变量命名如下：
/** 一级缓存 这个就是我们大名鼎鼎的单例缓存池 用于保存我们所有的单实例bean */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** 三级缓存 该map用户缓存 key为 beanName  value 为ObjectFactory(包装为早期对象) */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** 二级缓存 ，用户缓存我们的key为beanName value是我们的早期对象(对象属性还没有来得及进行赋值) */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

以 BeanA 和 BeanB 两个类相互依赖为例

3.2 创建原始 bean 对象

也就是所说的纯洁态Bean

instanceWrapper = createBeanInstance(beanName, mbd, args);
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);

假设 beanA 先被创建，创建后的原始对象为BeanA@1234，上面代码中的 bean 变量指向就是这个对象。

3.3 暴露早期引用

该方法用于把早期对象包装成一个ObjectFactory 暴露到三级缓存中用于将解决循环依赖...

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) { 
...
         //加入到三级缓存中，，，，，暴露早期对象用于解决循环依赖
         this.singletonFactories.put(beanName, singletonFactory);
 ...
}

beanA 指向的原始对象创建好后，就开始把指向原始对象的引用通过 ObjectFactory 暴露出去。getEarlyBeanReference 方法的第三个参数 bean 指向的正是 createBeanInstance 方法创建出原始 bean 对象 BeanA@1234。

3.4 解析依赖

populateBean(beanName, mbd, instanceWrapper);

还没有进行属性装配，自动注入的属性都是null

初始化好的Bean

populateBean 用于向 beanA 这个原始对象中填充属性，当它检测到 beanA 依赖于 beanB 时，会首先去实例化 beanB。

beanB 在此方法处也会解析自己的依赖，当它检测到 beanA 这个依赖，于是调用 BeanFactroy.getBean("beanA") 这个方法，从容器中获取 beanA。

3.5 获取早期引用

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   /**
    * 第一步:我们尝试去一级缓存(单例缓存池中去获取对象,一般情况从该map中获取的对象是直接可以使用的)
    * IOC容器初始化加载单实例bean的时候第一次进来的时候 该map中一般返回空
    */
   Object singletonObject = this.singletonObjects.get(beanName);
   /**
    * 若在第一级缓存中没有获取到对象,并且singletonsCurrentlyInCreation这个list包含该beanName
    * IOC容器初始化加载单实例bean的时候第一次进来的时候 该list中一般返回空,但是循环依赖的时候可以满足该条件
    */
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         /**
          * 尝试去二级缓存中获取对象(二级缓存中的对象是一个早期对象)
          * 何为早期对象:就是bean刚刚调用了构造方法，还来不及给bean的属性进行赋值的对象(纯净态)
          * 就是早期对象
          */
         singletonObject = this.earlySingletonObjects.get(beanName);
         /**
          * 二级缓存中也没有获取到对象,allowEarlyReference为true(参数是有上一个方法传递进来的true)
          */
         if (singletonObject == null && allowEarlyReference) {
            /**
             * 直接从三级缓存中获取 ObjectFactory对象 这个对接就是用来解决循环依赖的关键所在
             * 在ioc后期的过程中,当bean调用了构造方法的时候,把早期对象包裹成一个ObjectFactory
             * 暴露到三级缓存中
             */
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            //从三级缓存中获取到对象不为空
            if (singletonFactory != null) {
               /**
                * 在这里通过暴露的ObjectFactory 包装对象中,通过调用他的getObject()来获取我们的早期对象
                * 在这个环节中会调用到 getEarlyBeanReference()来进行后置处理
                */
               singletonObject = singletonFactory.getObject();
               //把早期对象放置在二级缓存,
               this.earlySingletonObjects.put(beanName, singletonObject);
               //ObjectFactory 包装对象从三级缓存中删除掉
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

接着上面的步骤讲:

populateBean 调用 BeanFactroy.getBean("beanA") 以获取 beanB 的依赖。
getBean("beanB") 会先调用 getSingleton("beanA")，尝试从缓存中获取 beanA。此时由于 beanA 还没完全实例化好
于是 this.singletonObjects.get("beanA") 返回 null。
接着 this.earlySingletonObjects.get("beanA") 也返回空，因为 beanA 早期引用还没放入到这个缓存中。
最后调用 singletonFactory.getObject() 返回 singletonObject，此时 singletonObject != null。singletonObject 指向 BeanA@1234，也就是 createBeanInstance 创建的原始对象。此时 beanB 获取到了这个原始对象的引用，beanB 就能顺利完成实例化。beanB 完成实例化后，beanA 就能获取到 beanB 所指向的实例，beanA 随之也完成了实例化工作。由于 beanB.beanA 和 beanA 指向的是同一个对象 BeanA@1234，所以 beanB 中的 beanA 此时也处于可用状态了。

以上的过程对应下面的流程图：

https://www.processon.com/view/link/5f1fb2cf1e08533a628a7b4c

4 如何进行拓展？

bean可以通过实现SmartInstantiationAwareBeanPostProcessor接口（一般这个接口供spring内部使用）的getEarlyBeanReference方法进行拓展

4.1 何时进行拓展？（进行bean的实例化时）

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)throws BeanCreationException {
//省略其他代码，只保留了关键代码
//...
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
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");
           }
          //将刚实例化好的bean添加到一级缓存中  
          addSingletonFactory(beanName, new ObjectFactory
                @Override
                public Object getObject()throws BeansException {
                        //执行拓展的后置处理器
                        return getEarlyBeanReference(beanName, mbd, bean);
                 }
          });
       }
}

4.2 getEarlyBeanReference方法

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   //判读我们容器中是否有InstantiationAwareBeanPostProcessors类型的后置处理器
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      //获取我们所有的后置处理器
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         //判断我们的后置处理器是不是实现了SmartInstantiationAwareBeanPostProcessor接口
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            //进行强制转换
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            //挨个调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
         }
      }
   }
   return exposedObject;
}

扩展示例：

@Component
public class TulingBPP implements SmartInstantiationAwareBeanPostProcessor {

   public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
      if(beanName.equals("instanceA") || beanName.equals("instanceB")) {
         JdkDynimcProxy jdkDynimcProxy = new JdkDynimcProxy(bean);
         return  jdkDynimcProxy.getProxy();
      }
      return bean;
   }
}

附带一张循环依赖的总图：

以上是关于Spring是如何解决循环依赖的？的主要内容，如果未能解决你的问题，请参考以下文章