循环依赖的问题_Spring5.0源码深度解析：SpringBean循环依赖问题解决方案，小白都能看懂...

一时失言乱红尘 2022-11-19 11:21 149阅读 0赞

点击上方“Java分享吧”，选择“设为星标”

优选有价值的技术文献，从我做起

源码分析篇章

Spring循环依赖

## **什么是Spring的循环依赖？循环依赖会存在哪些问题？** ##

示例：AService依赖BService; BService依赖AService

@Servicepublic class AService {
         //@Autowiredpublic BService bService;
    }

@Servicepublic class BService {
         @Autowiredpublic AService aService;
    }

![cc59d347ecd84b6bb7da35153cbef3ed.png][]

上面演示的例子就是循环注入

如果改为多例的化，运行时就会报错，循环引用异常，找不到对象

@Scope("prototype")

![3af73a2e88a17c34630d9c6c18f7cafc.png][]

Spring中的循环依赖问题在单例的情况下，Spring是已经帮我们解决好了，多例没有解决循环依赖问题。

为啥，多例的情况下 Spring没有去解决循环依赖问题？

> 因为在多例的情况下，设置的多例的对象没有明确哪一个，就会产生循环依赖问题。

## **Spring多例我们要：如何解决循环依赖问题？** ##

> 我们可以自己去：明确指定引用那个对象

@Service@Scope("prototype")public class AService {
         // @Autowiredpublic BService bService;// 为什么Aservice在创建的时候 为什么Bservice比ASERVICE 先创建public AService() {
         
            System.out.println("AService被Java的反射技术创建");
        }public void setbService(BService bService) {
         this.bService = bService;
        }
    }

@Service@Scope("prototype")public class BService {
         // @Autowiredpublic AService aService;public void setaService(AService aService) {
         this.aService = aService;
        }
    }

public class SpringApp {
         public static void main(String[] args) {
         //        1. ioc容器在创建的时候所有的单例对象是不是会被创建
           AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);//        // 对例子情况 当你在调用的时候才获取
            AService aSerivce = applicationContext.getBean("AService", AService.class);
            BService bSerivce = applicationContext.getBean("BService", BService.class);
            aSerivce.setbService(bSerivce);
            bSerivce.setaService(aSerivce);// 循环引用异常 找不到对象/**
             * 思考问题？如果我们的项目对象必须要是多例？而且必须要循环引用  明确的指定引用那个对象
             */
            String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();for (int i = 0; i < beanDefinitionNames.length; i++) {
         
                System.out.println(beanDefinitionNames[i]);
            }

![e7cc31b5e1380113a683c83a8c6e2de0.png][]

## **SpringBean循环依赖三级缓存概念** ##

思考问题：单例对象在什么时候创建？

在IOC容器被创建的时候创建

多例的情况下，是在getbean()调用的情况下创建。多例对象每次用完就会去销毁掉。

### **SpringBean Aservice对象被创建流程步骤源码分析** ###

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);

![1ffd8b619c319fbc644465555c168fbc.png][]

// Instantiate all remaining (non-lazy-init) singletons.finishBeanFactoryInitialization(beanFactory);

// Instantiate all remaining (non-lazy-init) singletons.beanFactory.preInstantiateSingletons();

![97442648ced1f6ebdc7c95c0fd41efb0.png][]

public Object getBean(String name) throws BeansException {
         return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

![321ad13413e44b64785b7a79be541bc4.png][]

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

获取缓存对象：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
         
        Object singletonObject = this.singletonObjects.get(beanName);    //根据BeanName去集合中查，查到就返回这个对象，【】【】【】一级缓存对象集合【】【】【】缓存完整对象【】【】完整对象表示对象已经创建完了，并且对象属性已经赋值了。if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
         
            Map var4 = this.singletonObjects;
            synchronized(this.singletonObjects) {
         
                singletonObject = this.earlySingletonObjects.get(beanName);    //查询二级缓存中是否有缓存对象if (singletonObject == null && allowEarlyReference) {
         
                    ObjectFactory> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);    //查询三级缓存，三级缓存中有的化，将三级缓存中的数据放入二级缓存中if (singletonFactory != null) {
         
                        singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);
                    }
                }
            }
        }return singletonObject;
    }

![0b78bcd8405d573807ecdc671e929d66.png][]

![e472b6ca15460c4bf2a26be97eaaf2ce.png][]

一级缓存没有找到，就去找二级缓存中找

![6b3edae3371eb05d8591475bd242460b.png][]

singletonObject == null && this.isSingletonCurrentlyInCreation(beanName) //一级缓存没有，并且singletonsCurrentlyInCreation判断是否之前标记为该对象开始创建

![a6acfb43e78c0bcab3d0837388e18205.png][]

![7e57c9802c6ddcbfe92c0e208faa8e1f.png][]

if (isPrototypeCurrentlyInCreation(beanName)) { //我们对象是单例的，所有不进入throw new BeanCurrentlyInCreationException(beanName);
    }

![4a5387f2399b91e839fe19958144fe8b.png][]

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) {
         if (this.singletonsCurrentlyInDestruction) {
         throw new BeanCreationNotAllowedException(beanName,"Singleton bean creation not allowed while 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 newSingleton = false;
             boolean recordSuppressedExceptions = (this.suppressedExceptions == null);if (recordSuppressedExceptions) {
         this.suppressedExceptions = new LinkedHashSet<>();
             }try {
         
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
             }catch (IllegalStateException ex) {
         // Has the singleton object implicitly appeared in the meantime ->// if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {
         throw ex;
                }
             }catch (BeanCreationException ex) {
         if (recordSuppressedExceptions) {
         for (Exception suppressedException : this.suppressedExceptions) {
         
                      ex.addRelatedCause(suppressedException);
                   }
                }throw ex;
             }finally {
         if (recordSuppressedExceptions) {
         this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
             }if (newSingleton) {
         
                addSingleton(beanName, singletonObject);
             }
          }return singletonObject;
       }
    }

![ae12dbb3d792ac0890e93c034b2af933.png][]

protected void beforeSingletonCreation(String beanName) {
         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
       }
    }

标识为该对象开始创建

![ce1413223c1cde4f11ab529fe43964db.png][]

最终调用

![fdd7c8919cd8dee5882b31aa99c7f31c.png][]

正真去创建我们的Bean对象：

![4d54f5801104ae6532a8e3dc63b31b11.png][]

既然要创建对象，先反射走无参构造函数，对象先实例化完成，在赋值

![16641cf83dbb6dd2cbbd503aef6c2773.png][]

执行这个方法，输出构造函数打印的语句，说明底层通过Java反射机制初始化的

![8d82de4cbee3260ec32465c1ce9b8208.png][]

在这之前，我们的对象属于婴儿对象，因为它的属性还没有赋值。都是称为婴儿对象。

那么什么时候赋值呢？

![bf224e07edbbda4622e30259766a75ba.png][]

populateBean(beanName, mbd, instanceWrapper);//这里给对象属性赋值

在给对象属性赋值之前：

![cafce9450b3da5ab94aab134ac48ef1d.png][]

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);
          }
       }
    }

![964014f3fdd218ff0154e2300ed02f3b.png][]

![f79e2bf6aac189469fe90cb5820cf98e.png][]

A对象坚持依赖B对象，这时候B对象也需要被创建

A对象已经存放在三级缓存中，这时候要去创建B对象

此时B对象也要走A对象流程

![e7afd6711bd044ce478e74ba1170dbb5.png][]

看下调用链

![79bd0d6dba3334f8939e33a64a739df0.png][]

![8b609cf2e611b62914142c6367628920.png][]

![6c38a5a4dbbf8f18821864b2d22aab35.png][]

也将B对象放入三级缓存

![3495428631869af9f5af6d54396d57e5.png][]

![40ad80127e0904da992ecb0ca578e7e2.png][]

总结下：

> AService在创建的时候，提前曝光存放到三级缓存中，AService发现依赖BService,这时候Bservice提前曝光存放到三级缓存中去。
> 
> 此时BService又依赖AService，此时BService经过赋值是完整对象，但是Aservice还是婴儿对象，没有完全创建完毕。
> 
> 就会去把BService对象注册到一级缓存中，同时会把之前缓存BService对象的二级缓存清除掉
> 
> AService对象依赖BService,BService此时已经创建成功了，那么AService在设置属性后，就直接把BService赋值给AService。

开始注册AService对象

![42f0a84071585de9b1f23cd7a750d63d.png][]

![8efa01ab8a7e04a3d9f8ac965c0f283e.png][]

## **总结：** ##

SpringBean中 Aservic对象被创建流程步骤源码分析：

> 1.  doGetBean创建我们bean对象
> 2.  getSingleton (beanName) 获取缓存对象
> 
> 注意：完整对象概念：对象已经实例化成功并且所有属性都已经赋值
> 
>  *  singletonObjects 一级缓存完整对象
>  *  earlySingletonObjects 二级缓存 缓存婴儿对象
>  *  singletonFactories 三级缓存存放婴儿对象
> 
> 理解概念:
> 
> 1.  完整对象表示该对象实例化完成并且所有的属性已经赋值。
> 2.  婴儿对象(提前对象)对象已经实例化完成但是属性没有赋值的。
> 
> singletonObject ==null&&this.singletonsCurrentlyInCreation.contains(beanName);
> 
> \{
> 
> 才能够查询二级缓存
> 
> \}  
> singletonsCurrentlyInCreation ：标记为该对象开始创建
> 
> 1.  getSingleton(String beanName, ObjectFactory> singletonFactory)
> 
> this.singletonsCurrentlyInCreation.add(beanName) 表示该对象已经开始创建
> 
> 1.  createBean() →doCreateBean
> 2.  addSingletonFactory  将婴儿对象(不完整对象也就是只是实例化完成但是属性没有赋值的) 存放三级缓存中。
> 3.  A对象已经存放到三级缓存中，开始给对象属性赋值的时候 需要创建B对象。
> 
> A对象检查发现依赖B对象 这时候B对象也需要被创建

--------------------

历史技术文献

*  多线程进阶，JUC并发编程之抽象同步队列AQS框架设计理念一探究竟
 *  今日实战案例：设计模式之外观模式(门面模式)，并利用到接口设计当中
 *  谈谈我是如何在聚合支付平台，巧用模板+工厂设计模式来实现异步回调，看完就能明白
 *  京东Java高级工程师，浅谈代理设计模式，看完就能明白了~
 *  设计模式之策略模式实战案例，如何重构聚合支付平台，对接支付宝、微信、银联支付？

文章有帮助可以点个「在看」或「分享」，分享不易，请兄弟姐妹们点下吧！

我是吧主，Java干货分享，记录每一位程序员的点点滴滴故事，每篇文章原创与当下程序员，架构师，日常总结经验，全网唯一良心原创无广告平台~

[cc59d347ecd84b6bb7da35153cbef3ed.png]: /images/20221119/ce419cb65ab64fa78174dbf93a67ce82.png
[3af73a2e88a17c34630d9c6c18f7cafc.png]: /images/20221119/a3c4f842d22743b198d7468e36f4fd2e.png
[e7cc31b5e1380113a683c83a8c6e2de0.png]: /images/20221119/cebcdb52a9764417852f8f99220dfe72.png
[1ffd8b619c319fbc644465555c168fbc.png]: /images/20221119/964d5a4e0a54411a832e13ac40a7a612.png
[97442648ced1f6ebdc7c95c0fd41efb0.png]: /images/20221119/9a03fccbdacb464c932753d80c2e5cea.png
[321ad13413e44b64785b7a79be541bc4.png]: /images/20221119/ea1ba2c600ec4f0b8fc627a90cd8c2e5.png
[0b78bcd8405d573807ecdc671e929d66.png]: /images/20221119/91319e333e6845439a877d62531d0c5e.png
[e472b6ca15460c4bf2a26be97eaaf2ce.png]: /images/20221119/2df6cd42f86f40a9b6c943fac9d57edb.png
[6b3edae3371eb05d8591475bd242460b.png]: /images/20221119/1679937c32494379b1c816130827dab7.png
[a6acfb43e78c0bcab3d0837388e18205.png]: /images/20221119/379f993170944ff99b22228408a3cd6a.png
[7e57c9802c6ddcbfe92c0e208faa8e1f.png]: /images/20221119/829fd56ebbdc4dbd8413e7c9aa394acd.png
[4a5387f2399b91e839fe19958144fe8b.png]: /images/20221119/06edfdcf197c4e9fb49927a6d91e7a9c.png
[ae12dbb3d792ac0890e93c034b2af933.png]: /images/20221119/cb493f808ae840babd160bd628636da9.png
[ce1413223c1cde4f11ab529fe43964db.png]: /images/20221119/fbec07d30a514a2bbe195270ea1f8c79.png
[fdd7c8919cd8dee5882b31aa99c7f31c.png]: /images/20221119/b5e7dcad11c842f6bebb7d4edc77e465.png
[4d54f5801104ae6532a8e3dc63b31b11.png]: https://img-blog.csdnimg.cn/img_convert/4d54f5801104ae6532a8e3dc63b31b11.png
[16641cf83dbb6dd2cbbd503aef6c2773.png]: https://img-blog.csdnimg.cn/img_convert/16641cf83dbb6dd2cbbd503aef6c2773.png
[8d82de4cbee3260ec32465c1ce9b8208.png]: https://img-blog.csdnimg.cn/img_convert/8d82de4cbee3260ec32465c1ce9b8208.png
[bf224e07edbbda4622e30259766a75ba.png]: https://img-blog.csdnimg.cn/img_convert/bf224e07edbbda4622e30259766a75ba.png
[cafce9450b3da5ab94aab134ac48ef1d.png]: https://img-blog.csdnimg.cn/img_convert/cafce9450b3da5ab94aab134ac48ef1d.png
[964014f3fdd218ff0154e2300ed02f3b.png]: https://img-blog.csdnimg.cn/img_convert/964014f3fdd218ff0154e2300ed02f3b.png
[f79e2bf6aac189469fe90cb5820cf98e.png]: https://img-blog.csdnimg.cn/img_convert/f79e2bf6aac189469fe90cb5820cf98e.png
[e7afd6711bd044ce478e74ba1170dbb5.png]: https://img-blog.csdnimg.cn/img_convert/e7afd6711bd044ce478e74ba1170dbb5.png
[79bd0d6dba3334f8939e33a64a739df0.png]: https://img-blog.csdnimg.cn/img_convert/79bd0d6dba3334f8939e33a64a739df0.png
[8b609cf2e611b62914142c6367628920.png]: https://img-blog.csdnimg.cn/img_convert/8b609cf2e611b62914142c6367628920.png
[6c38a5a4dbbf8f18821864b2d22aab35.png]: https://img-blog.csdnimg.cn/img_convert/6c38a5a4dbbf8f18821864b2d22aab35.png
[3495428631869af9f5af6d54396d57e5.png]: https://img-blog.csdnimg.cn/img_convert/3495428631869af9f5af6d54396d57e5.png
[40ad80127e0904da992ecb0ca578e7e2.png]: https://img-blog.csdnimg.cn/img_convert/40ad80127e0904da992ecb0ca578e7e2.png
[42f0a84071585de9b1f23cd7a750d63d.png]: https://img-blog.csdnimg.cn/img_convert/42f0a84071585de9b1f23cd7a750d63d.png
[8efa01ab8a7e04a3d9f8ac965c0f283e.png]: https://img-blog.csdnimg.cn/img_convert/8efa01ab8a7e04a3d9f8ac965c0f283e.png