springboot bean循环依赖实现以及源码分析

    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.5.1</version>
        <relativepath/> <!-- lookup parent from repository -->
    </parent>

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.component;

@component
public class servicea {
    @autowired
    private serviceb serviceb;
}

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.component;

@component
public class serviceb {
    @autowired
    private servicea servicea;
}

public <t> t getbean(class<t> requiredtype) throws beansexception
public object getbean(string name) throws beansexception
public <t> map<string, t> getbeansoftype(@nullable class<t> type) throws beansexception
public map<string, object> getbeanswithannotation(class<? extends annotation> annotationtype)
public void preinstantiatesingletons() throws beansexception 

 public object getbean(string name) throws beansexception {
  return dogetbean(name, null, null, false);
 }

 public <t> t getbean(string name, @nullable class<t> requiredtype, @nullable object... args)
   throws beansexception {

  return dogetbean(name, requiredtype, args, false);
 }

 protected <t> t dogetbean(
   string name, @nullable class<t> requiredtype, @nullable object[] args, boolean typecheckonly)
   throws beansexception {

 protected <t> t dogetbean(
   string name, @nullable class<t> requiredtype, @nullable object[] args, boolean typecheckonly)
   throws beansexception {
   //如果bean之前存在，这里返回的shareinstance就是非空，就会从后面的if分支中返回，如果bean之前不存在，就会执行后面的bean创建及注入属性的过程
   object sharedinstance = getsingleton(beanname);
   if (sharedinstance != null && args == null) {
   ......
   //如果当前不只是检查，而且是创建bean，这个参数就是false，在这里就会做个bean创建的标记，把beanname 加到alreadycreated里面去
   if (!typecheckonly) {
    markbeanascreated(beanname);
   }
    //我们当前要创建的bean是单例的，就会走到这里去，下面我们走到里面的调用去看看
    // create bean instance.
    if (mbd.issingleton()) {
     sharedinstance = getsingleton(beanname, () -> {
      try {
       return createbean(beanname, mbd, args);
      }
      catch (beansexception ex) {
       // explicitly remove instance from singleton cache: it might have been put there
       // eagerly by the creation process, to allow for circular reference resolution.
       // also remove any beans that received a temporary reference to the bean.
       destroysingleton(beanname);
       throw ex;
      }
     });
     beaninstance = getobjectforbeaninstance(sharedinstance, name, beanname, mbd);
    }

  }

 public object getsingleton(string beanname, objectfactory<?> singletonfactory) {
  assert.notnull(beanname, "bean name must not be null");
  synchronized (this.singletonobjects) {
                ......
                //这里会把当前bean的名字加入到当前正在创建的单例对象集合singletonscurrentlyincreation中
    beforesingletoncreation(beanname);
    ......
    try {
                    //这里就是调用上面的return createbean(beanname, mbd, args);这个方法，我们进这里面去看看
     singletonobject = singletonfactory.getobject();
     newsingleton = true;
    }
    ......
   }
   return singletonobject;
  }
 }

 @override
 protected object createbean(string beanname, rootbeandefinition mbd, @nullable object[] args)
   throws beancreationexception {
  ......
  // make sure bean class is actually resolved at this point, and
  // clone the bean definition in case of a dynamically resolved class
  // which cannot be stored in the shared merged bean definition.
        //在这里获取要创建的bean的class对象
  class<?> resolvedclass = resolvebeanclass(mbd, beanname);
  ......
  try {
            //调用这里来创建，我们再走到这里面去看看
            //3个参数分别为
            //1、beanname  bean对象的名字
            //2、mbdtouserootbeandefinition对象，可以认为就是bean的元数据信息，包含bean的类对象，bean的类上注解，bean实际位置路径等等
            //3、args  bean对象的构造方法的实参，这里一般是空的
   object beaninstance = docreatebean(beanname, mbdtouse, args);
   if (logger.istraceenabled()) {
    logger.trace("finished creating instance of bean '" + beanname + "'");
   }
   return beaninstance;
  }
  ......
 }

protected object docreatebean(string beanname, rootbeandefinition mbd, @nullable object[] args)
      throws beancreationexception {

   ......
   //真正创建bean对象是在这里，这里返回的instancewrapper是bean对象的类实例的包装对象beanwrapper
   if (instancewrapper == null) {
      instancewrapper = createbeaninstance(beanname, mbd, args);
   }
   //这里的bean就是实际创建的bean对象的类实例
   object bean = instancewrapper.getwrappedinstance();
   class<?> beantype = instancewrapper.getwrappedclass();
   if (beantype != nullbean.class) {
      mbd.resolvedtargettype = beantype;
   }
 ......
   // eagerly cache singletons to be able to resolve circular references
   // even when triggered by lifecycle interfaces like beanfactoryaware.
   //看上面的注释大概也能明白， 大概意思就是早期的单例缓存，为了解决由 beanfactoryaware等等触发的循环依赖
   //mbd.issingleton()  表示bean是单例的(这个是bean对应的类上的，默认就是单例)，
   //this.allowcircularreferences 允许循环引用,这个是beanfactory的成员属性，默认也是true
   //issingletoncurrentlyincreation(beanname) 表示是否在当前正在创建的bean集合中。beforesingletoncreation(beanname);我们在前面执行过这句就加到正在创建的bean集合中了
   //这里earlysingletonexposure 就是true了，会进到if分支中
   boolean earlysingletonexposure = (mbd.issingleton() && this.allowcircularreferences &&
         issingletoncurrentlyincreation(beanname));
   if (earlysingletonexposure) {
      if (logger.istraceenabled()) {
         logger.trace("eagerly caching bean '" + beanname +
               "' to allow for resolving potential circular references");
      }
      //这句主要是将将() -> getearlybeanreference(beanname, mbd, bean) 这个lambda表达式存储到this.singletonfactories集合中
      addsingletonfactory(beanname, () -> getearlybeanreference(beanname, mbd, bean));
   }

   // initialize the bean instance.
   object exposedobject = bean;
   try {
      //在这里就会进行属性填充，完成成员注入等等，也就是在这里servicea这个bean会注入serviceb这个成员属性,我们走进这个方法去看看
      populatebean(beanname, mbd, instancewrapper);
      ......
   }
  ......

   return exposedobject;
}

 protected void populatebean(string beanname, rootbeandefinition mbd, @nullable beanwrapper bw) {
  ......
  if (hasinstawarebpps) {
   if (pvs == null) {
    pvs = mbd.getpropertyvalues();
   }
   //真正的属性注入是在这里完成的，aop也是在这里来完成的。这里是获取beanfactory中的instantiationawarebeanpostprocessor对bean对象进行增强
   //如果属性注入用的是@resource，就会用commonannotationbeanpostprocessor来完成
   //如果属性注入用的是@autowired,就会用autowiredannotationbeanpostprocessor来完成
   //如果是aop 就会使用infrastructureadvisorautoproxycreator来生成对应的代理对象
   //我们这里使用的是@autowired,所以会用autowiredannotationbeanpostprocessor来完成注入。我们走到它的postprocessproperties的去看看
   for (instantiationawarebeanpostprocessor bp : getbeanpostprocessorcache().instantiationaware) {
    propertyvalues pvstouse = bp.postprocessproperties(pvs, bw.getwrappedinstance(), beanname);
    ......
 }

 @override
 public propertyvalues postprocessproperties(propertyvalues pvs, object bean, string beanname) {
        //这里主要是获取bean的类属性和方法上的org.springframework.beans.factory.annotation.autowired,org.springframework.beans.factory.annotation.value注解来进行注入
  injectionmetadata metadata = findautowiringmetadata(beanname, bean.getclass(), pvs);
  try {
            //继续进去看看
   metadata.inject(bean, beanname, pvs);
  }
  ......
 }

public void inject(object target, @nullable string beanname, @nullable propertyvalues pvs) throws throwable {
   ......
   //对每一个属性分别进行注入，继续进去
         element.inject(target, beanname, pvs);
      }
   }
}

    @override
    protected void inject(object bean, @nullable string beanname, @nullable propertyvalues pvs) throws throwable {
     field field = (field) this.member;
     object value;
     //如果之前缓存过就从缓存取，我们是第一次注入，所以之前没有缓存，不会走这个分支
     if (this.cached) {
      try {
       value = resolvedcachedargument(beanname, this.cachedfieldvalue);
      }
      catch (nosuchbeandefinitionexception ex) {
       // unexpected removal of target bean for cached argument -> re-resolve
       value = resolvefieldvalue(field, bean, beanname);
      }
     }
     else {
      //会走这里来解析字段的值，再进去
      value = resolvefieldvalue(field, bean, beanname);
     }
     if (value != null) {
      reflectionutils.makeaccessible(field);
      field.set(bean, value);
     }
    }

  @nullable
  private object resolvefieldvalue(field field, object bean, @nullable string beanname) {
   //创建字段的包装类dependencydescriptor
   dependencydescriptor desc = new dependencydescriptor(field, this.required);

   try {
    //调用这里完成对应字段值的查找,再进去
    value = beanfactory.resolvedependency(desc, beanname, autowiredbeannames, typeconverter);
   }
   catch (beansexception ex) {
    throw new unsatisfieddependencyexception(null, beanname, new injectionpoint(field), ex);
   }
   synchronized (this) {
    //获取到值之后，进行缓存
    if (!this.cached) {
      ......
     }
     this.cachedfieldvalue = cachedfieldvalue;
     this.cached = true;
    }
   }
   return value;
  }
 }

 public object resolvedependency(dependencydescriptor descriptor, @nullable string requestingbeanname,
   @nullable set<string> autowiredbeannames, @nullable typeconverter typeconverter) throws beansexception {

  descriptor.initparameternamediscovery(getparameternamediscoverer());
  if (optional.class == descriptor.getdependencytype()) {
   return createoptionaldependency(descriptor, requestingbeanname);
  }
  else if (objectfactory.class == descriptor.getdependencytype() ||
    objectprovider.class == descriptor.getdependencytype()) {
   return new dependencyobjectprovider(descriptor, requestingbeanname);
  }
  else if (javaxinjectproviderclass == descriptor.getdependencytype()) {
   return new jsr330factory().createdependencyprovider(descriptor, requestingbeanname);
  }
  else {
   //当前的类是一个普通的class，会走到这里面，由于我们的bean没有lazy注解，所以这里返回时null,走到下面的if分支
   object result = getautowirecandidateresolver().getlazyresolutionproxyifnecessary(
     descriptor, requestingbeanname);
   if (result == null) {
    //在这里我们看下这里的入参。
    //descriptor是包含了需要注入的字段的信息。
    //requestingbeanname是当前正在创建的bean的名字servicea,
    //autowiredbeannames是当前需要注入的字段的对应的bean的名字的集合，这里只有serviceb
    //typeconverter这个是进行注入时做类型转换的，这里我们可以不用关注这个
    result = doresolvedependency(descriptor, requestingbeanname, autowiredbeannames, typeconverter);
   }
   return result;
  }
 }

 @nullable
 public object doresolvedependency(dependencydescriptor descriptor, @nullable string beanname,
   @nullable set<string> autowiredbeannames, @nullable typeconverter typeconverter) throws beansexception {
   ......
   if (instancecandidate instanceof class) {
    //又会调用到这里,我们再进入到dependencydescriptor的resolvecandidate去看看
                //注意：这里的autowiredbeanname是我们需要注入的属性名这里是serviceb
    instancecandidate = descriptor.resolvecandidate(autowiredbeanname, type, this);
   }
   ......
 }

 public object resolvecandidate(string beanname, class<?> requiredtype, beanfactory beanfactory)
   throws beansexception {
  //看到没，到这里就出现循环调用了，到这里又会重新调用beanfactory.getbean("serviceb")去创建serviceb的bean对象，完成后注入到serivcea对应的bean上的属性上来，这时代码又会从本节开头的位置开始执行，先创建serviceb对象实例，再去注入serviceb对象的servicea属性。
        //最终会执行到beanfactory.getbean("servicea")这里
  return beanfactory.getbean(beanname);
 }

 protected <t> t dogetbean(
   string name, @nullable class<t> requiredtype, @nullable object[] args, boolean typecheckonly)
   throws beansexception {
  //我们第二部分就是从这里开始的，又走回来了，但这次又会有所不同
  string beanname = transformedbeanname(name);
  object beaninstance;

  // eagerly check singleton cache for manually registered singletons.
  //这次我们这里返回的就不是空了，sharedinstance对象的值就是对应servicea的bean对象了，这次就会从if分支中返回，而之前我们不会进这里的if分支而是进入else分支导致后面出现了循环依赖的问题，这次我们进到这个方法看看
  object sharedinstance = getsingleton(beanname);
  if (sharedinstance != null && args == null) {
   if (logger.istraceenabled()) {
    if (issingletoncurrentlyincreation(beanname)) {
     logger.trace("returning eagerly cached instance of singleton bean '" + beanname +
       "' that is not fully initialized yet - a consequence of a circular reference");
    }
    else {
     logger.trace("returning cached instance of singleton bean '" + beanname + "'");
    }
   }
   beaninstance = getobjectforbeaninstance(sharedinstance, name, beanname, null);
  }

 @nullable
 public object getsingleton(string beanname) {
  //再点进去
  return getsingleton(beanname, true);
 }

 protected object getsingleton(string beanname, boolean allowearlyreference) {
  // quick check for existing instance without full singleton lock
  object singletonobject = this.singletonobjects.get(beanname);
         //这里由于当前的servicea bean还没完成创建，所以这里singletonobject返回的是空，
        //再看看 issingletoncurrentlyincreation(beanname)这里，由于我们在创建servicea过程中有这么一句beforesingletoncreation(beanname)(不清楚这句的搜索下本文，上面就有讲到)，所有这个条件是true。这时我们就会进入if分支中
  if (singletonobject == null && issingletoncurrentlyincreation(beanname)) {
   singletonobject = this.earlysingletonobjects.get(beanname);
           //由于我们是第一次进入这里，所以this.earlysingletonobjects.get(beanname)返回的也是null
           //我们的入参 allowearlyreference是true,会继续进到这个if分支中
   if (singletonobject == null && allowearlyreference) {
    synchronized (this.singletonobjects) {
     // consistent creation of early reference within full singleton lock
     singletonobject = this.singletonobjects.get(beanname);
                    //这里的singletonobject还是null,继续进到if分支
     if (singletonobject == null) {
      singletonobject = this.earlysingletonobjects.get(beanname);
      if (singletonobject == null) {
                            //最终会走到这里，在创建servicea对象之后，属性注入之前，执行了这句 addsingletonfactory(beanname, () -> getearlybeanreference(beanname, mbd, bean))(不清楚的搜索下本文，上面有说到)，所以这里返回的singletonfactory是个lamdba表达式，getearlybeanreference(beanname, mbd, bean))附带了3个参数，第一个beanname是serivcea,mdb是对应servicea的附带servicea元数据信息的rootbeandefinition对象，bean就是创建出来的servicea对象
       objectfactory<?> singletonfactory = this.singletonfactories.get(beanname);
       if (singletonfactory != null) {
                                //这里就会调用getearlybeanreference(beanname, mbd, bean)对servicea对象进行一个getearlybeanreference增强后返回，返回后放置到earlysingletonobjects中，并从singletonfactories中删除
        singletonobject = singletonfactory.getobject();
        this.earlysingletonobjects中，并从.put(beanname, singletonobject);
        this.singletonfactories.remove(beanname);
       }
      }
     }
    }
   }
  }
  return singletonobject;
 }

 public object getsingleton(string beanname, objectfactory<?> singletonfactory) {
    ......
    finally {
     //在这里从singletonscurrentlyincreation中移除掉
     aftersingletoncreation(beanname);
    }
    if (newsingleton) {
     //将servicea bean对象添加到singletonobjects，registeredsingletons中
     //从singletonfactories,earlysingletonobjects中移除掉
     addsingleton(beanname, singletonobject);
    }
   }
   return singletonobject;
  }
 }