关于Spring源码是如何解决Bean的循环依赖

目录

两个单例testa testb 互相依赖的实例化过程源码中的实现方式重要流程梳理

首先需要明白一点，只有scop为(singleton)单例类型的bean，spring才支持循环依赖。

scope为(prototype)原型类型的bean是不支持的，它每次调用都会创建一个新的实例，spring 在实例化bean的时候会先实例化bean的各种属性依赖，如果testa testb是原型类型且相互依赖则会出现new testa 的时候，先new testb，然后new testb的时候又去new testa会出现无限套娃的情况。

两个单例testa testb 互相依赖的实例化过程

spring容器创建单例“testa”bean，首先根据无参构造器创建bean，并暴露一个“objectfactory”用于返回一个提前暴露正在创建中的bean，并将“testa”标识符放到“当前创建bean池”，然后进行tter注入“testb”。

spring容器创建单例“testb”bean，首先根据无参构造器创建bean，并暴露一个“objectfactory”用于返回一个提前暴露正在创建中的bean，并将“testb”标识符放到“当前创建bean池”，然后进行tter注入“testa”，此时由于通过 暴露”objectfactory” 已提前暴露了一个正在创建中的”testa” bean，所以直接注入，完成testb的创建，注入testa中，再完成testa的创建。

源码中的实现方式

首先了解一下创建bean过程中最重要的三个map

以下三个map均来自于 defaultsingletonbeanregistry

map<string, object> singletonobjects = new concurrenthashmap<>(256);map<string, objectfactory<?>> singletonfactories = new hashmap<>(16);map<string, object> earlysingletonobjects = new concurrenthashmap<>(16);

singletonobjects：用于保存beanname和创建bean实例之间的关系，bean name 一＞ bean instance。singletonfactories：用于保存beanname和创建bean的工厂之间的关系，bean name 一＞objectfactory。earlysingletonobjects：也是保存beanname和创建bean实例之间的关系，与singletonobjects的不同之处在于，当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getbean方法获取到了，其目的是用来检测循环引用。

总结：后面两个map实际上就是为了辅助第一个map缓存bean的实例，完成后数据就在后面两个map中清掉了。

测试代码：

// 1. 引入依赖，springboot项目只需要这一个依赖即可测试<dependency>    <groupid>org.springframework.boot</groupid>    <artifactid>spring-boot-starter-web</artifactid></dependency>// 2. 两个测试类@componentpublic class testa {    @autowired    private testb testb;}@componentpublic class testb {    @autowired    private testa testa;}

注意：下面所有的方法都只是源码的部分截取，把我认为重要的逻辑放在这里的，大家阅读时，可提前在ide中打开文中提到的几个类，在相应方法处，打上断点可以直接调试，bean的实例化过程就一目了然了。

1. abstractbeanfactory 类中 getbean方法

public <t> t getbean(string name, @nullable class<t> requiredtype, @nullable object... args)  throws beanxception { return dogetbean(name, requiredtype, args, fal);}

2. abstractbeanfactory 类中 dogetbean方法

// // 2.1 从缓存中获取实例bean，第一次肯定没有，为nullobject sharedinstance = getsingleton(beanname);if (sharedinstance != null && args == null) { beaninstance = getobjectforbeaninstance(sharedinstance, name, beanname, null);}el{ // create bean instance. if (mbd.issingleton()) {  // 2.2 获取缓存中的实例  sharedinstance = getsingleton(beanname, () -> {   try {    // 2.3 调用创建bean实例的方法    return createbean(beanname, mbd, args);   }   });  beaninstance = getobjectforbeaninstance(sharedinstance, name, beanname, mbd); }}

3. defaultsingletonbeanregistry 类中 getsingleton方法，2.1调用的就是这里的3.1

// 3.1@override@nullablepublic object getsingleton(string beanname) { return getsingleton(beanname, true);}// 3.2@nullableprotected object getsingleton(string bea名书排行榜nname, boolean allowearlyreference) { // quick check for existing instance without full singleton lock object singletonobject = this.singletonobjects.get(beanname); if (singletonobject == null && issingletoncurrentlyincreation(beanname)) {  singletonobject = this.earlysingletonobjects.get(beanname);  if (singletonobject == null && allowearlyreference) {   synchronized (this.singletonobjects) {    // consistent creation of early reference within full singleton lock    singletonobject = this.singletonobjects.get(beanname);    if (singletonobject == null) {     singletonobject = this.earlysingletonobjects.get(beanname);     if (singletonobject == null) {      objectfactory<?> singletonfactory = this.singletonfactories.get(beanname);      if (singletonfactory != null) {       singletonobject = singletonfactory.getobject();       this.earlysingletonobjects.put(beanname, singletonobject);       this.singletonfactories.remove(beanname);      }     }    }   }  } } return singletonobject;}

3.1和3.2后面会反复获取的，第一次因为issingletoncurrentlyincreation(beanname)返回fal，所以返回null

4. defaultsingletonbeanregistry 类中 getsingleton方法，获取objectfactory，2.2就是调用的这里

public object getsingleton(string beanname, objectfactory<?> singletonfactory) { synchronized (this.singletonobjects) {  object singletonobject = this.singletonobjects.get(beanname);  if (singletonobject == null) {   beforesingletoncreation(beanname);   boolean newsingleton = fal;   try {    // 4.0.1    singletonobject = singletonfactory.getobject();    newsingleton = true;   }   finally {    aftersingletoncreation(beanname);   }   if (newsingleton) {    // 4.0.2    addsingleton(beanname, singletonobject);   }  }  return singletonobject; }}protected void addsingleton(string beanname, object singletonobject) { synchronized (this.singletonobjects) {  this.singletonobjects.put(beanname, singletonobject);  this.singletonfactories.remove(beanname);  this.earlysingletonobjects.remove(beanname);  this.registeredsingletons.add(beanname); }}

这面重点分析beforesingletoncreation 、aftersingletoncreation 和 addsingleton这三个方法

4.1 defaultsingletonbeanregistry 中 beforesingletoncreation方法 和 aftersingletoncreation方法

protected void beforesingletoncreation(string beanname) { if (!this.increationcheckexclusions.contains(beanname) && !this.singletonscurrentlyincreation.add(beanname)) {  throw new beancurrentlyincreationexception(beanname); }}protected void aftersingletoncreation(string beanname) { if (!this.increationcheckexclusions.contains(beanname) && !this.singletonscurrentlyincreation.remove(beanname)) {  throw new illegalstateexception("singleton '" + beanname + "' isn't currently in creation"); }}

重点：这两个方法的目的就是为 singletonscurrentlyincreation 这个t集合添加和删除当前创建的bean，为后续处理做铺垫，addsingleton方法主要是对bean缓存map的维护。

4.2 现在回到第4步的4.0.1的方法中，singletonobject = singletonfactory.getobject();这行代码就是正真获取实例对象的地方，singletonfactory 是怎么拿到的呢，这就要回到第2步的2.3步骤中，通过createbean方法返回了objectfactory类型的singletonfact重温入党誓言ory，下面看createbean是如何创建bean的：

protected object createbean(string beanname, rootbeandefinition mbd, @nullable object[] args) throws beancreationexception {   try {  object beaninstance = docreatebean(beanname, mbdtou, args);  return beaninstance; } }// 看过一些spring源码的都应该明白spring真正做事情的都是以doxxx开头的，这里也不例外// 相信大家都已经明白真正创建bean是由docreatebean方法实现的，下面我们继续分析这个方法protected object docreatebean(string beanname, rootbeandefinition mbd, @nullable object[] args) throws beancreationexception { beanwrapper instancewrapper = null; if (instancewrapper == null) {  instancewrapper = createbeaninstance(beanname, mbd, args); } object bean = instancewrapper.getwrappedinstance(); boolean earlysingletonexposure = (mbd.issingleton() && this.allowcircularreferences  && issingletoncurrentlyincreation(beanname)); if (earlysingletonexposure) {  addsingletonfactory(beanname, () -> getearlybeanreference(beanname, mbd, bean)); } object expodobject = bean; try {  // 4.3 填充bean的属性，依赖bean就是这里初始化的  populatebean(beanname, mbd, instancewrapper);  expodobject = initializebean(beanname, expodobject, mbd); } if (earlysingletonexposure) {  // 4.4 再次获取缓存中的实例，注意这里可以从两个缓存处获取，第一个是earlysingletonobjects map，第二个是singletonfactories map获取  object earlysingletonreference = getsingleton(beanname, fal);  if (earlysingletonreference != null) {   if (expodobject == bean) {    expodobject = earlysingletonreference;   }  } } return expodobject;}// issingletoncurrentlyincreation方法public boolean issingletoncurrentlyincreation(string beanname) { return this.singletonscurrentlyincreation.contains(beanname);}// addsingletonfactoryprotected void addsingletonfactory(string beanname, objectfactory<?> singletonfactory) { asrt.notnull(singletonfactory, "singleton factory m计算机考试题ust not be null"); synchronized (this.singletonobjects) { if (!this.singletonobjects.containskey(beanname)) {  this.singletonfactories.put(beanname, singletonfactory);  this.earlysingletonobjects.remove(beanname);  this.registeredsingletons.add(beanname); }}

重要流程梳理

1.docreatebean中主要分为两部分，第一部分通过instancewrapper得到beanfactory的实例，内部由反射实现，这里我们不多做分析，变量earlysingletonexposure，它由三部分得到，前面两个都很容易理解，第三部分则出现了我们在4.1中做铺垫的集合 singletonscurrentlyincreation。由于在4.1中已经设置了，所以earlysingletonexposure肯定为true，因此执行addsingletonfacatory为singletonfactories map赋值，完成了beanname -> objectfactory的映射

2.populatebean方法中则会完成对bean依赖属性的注入，因此代码走到4.3的时候，testa的创建就停止了，会回到第一步去获取testb，然后又是对testb的创建，最后会再次走到4.3，完成testa 和 testb 的objectfactory的映射，即将它们放入 singletonfactories map缓存中。

3.创建testb 再次走到4.3的时候，又会去初始化testb的依赖 testa，此时会再次去第一步获取，再次走到2.1的时候，因为testa的objectfactory是有值的，所以通过它能够获取到testa 的singletonobject，此时就把testa 的实例放入了 earlysingletonobjects中，只不过此时的testa实例是不完整的，还没有完成属性testb依赖的初始化。最后返回testa的singletonobject引用，完成testb对其依赖testa的初始化，然后再去 4.4 获取testb的缓存，这里依旧是没有的，然后返回到4.0.2处，将testb加入singletonobjects map缓存，并移除testb在singletonfactories中的缓存，这里testb 在 earlysingletonobjects中实际上是没有值的，当然有的话也会移除，因为singletonobjects 中已经拿到值了，所以另外两个辅助map就不用保留数据了。

4.上面已经完成testb的初始化并放入singletonobjects 缓存在网上找工作了，继续走，就又回到了4.3，继续完成对testa的创建，走到4.4的时候，继续去缓存中获取testa，因为之前已经把testa放入earlysingletonobjects map中高考卷了，所以4.4是直接能够获取到testa的实例的。

5.继续走，就又来到了4.0.2，不过这次是针对testa的，addsingleton方法中会把testa的实例给放入singletonobjects map缓存中，同时移除singletonfactories 和 earlysingletonobjects map缓存的testa，完成testa和testb的实例化。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持www.887551.com。