关于java:spring解决循环依赖为什么要用三级缓存

关注“苏三说技术”，回复：开发手册、工夫治理有惊喜。

兴许有些敌人对spring的循环依赖问题并不理解，让咱们先一起看看这个例子。

@Servicepublic class AService {    private BService bService;    public AService(BService bService) {        this.bService = bService;    }    public void doA() {        System.out.println("call doA");    }}

@Servicepublic class BService {    private AService aService;    public BService(AService aService) {        this.aService = aService;    }    public void doB() {        System.out.println("call doB");    }}

@RequestMapping("/test")@RestControllerpublic class TestController {    @Autowired    private AService aService;    @RequestMapping("/doSameThing")    public String doSameThing() {        aService.doA();        return "success";    }}

@SpringBootApplicationpublic class Application {    /**     * 程序入口     * @param args 程序输出参数     */    public static void main(String[] args) {        new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);    }}

咱们在运行Application类的main办法启动服务时，报了如下异样：

Requested bean is currently in creation: Is there an unresolvable circular reference?

这里提醒得很显著，呈现了循环依赖。

什么是循环依赖？

循环依赖是实例a依赖于实例b，实例b又依赖于实例a。

或者实例a依赖于实例b，实例b依赖于实例c，实例c又依赖于实例a。

像这种多个实例之间的相互依赖关系形成一个环形，就是循环依赖。

为什么会造成循环依赖？

下面的例子中AService实例化时会调用构造方法 public AService(BService bService)，该构造方法依赖于BService的实例。此时BService还没有实例化，须要调用构造方法public BService(AService aService)能力实现实例化，该构造方法偶合又须要AService的实例作为参数。因为AService和BService都没有提前实例化，在实例化过程中又相互依赖对方的实例作为参数，这样形成了一个死循环，所以最终都无奈再实例化了。

spring要如何解决循环依赖？

只须要将下面的例子略微调整一下，不必构造函数注入，间接应用Autowired注入。

@Servicepublic class AService {    @Autowired    private BService bService;    public AService() {    }    public void doA() {        System.out.println("call doA");    }}

@Servicepublic class BService {    @Autowired    private AService aService;    public BService() {    }    public void doB() {        System.out.println("call doB");    }}

咱们看到能够失常启动了，阐明循环依赖被本人解决了

spring为什么能循环依赖？

调用applicationContext.getBean(xx)办法，最终会调到AbstractBeanFactory类的doGetBean办法。因为该办法很长，我把局部不相干的代码省略掉了。

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { final String beanName = transformedBeanName(name);    Object bean;    Object sharedInstance = getSingleton(beanName);    if (sharedInstance != null && args == null) {       省略........      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);    } else {       省略........        if (mbd.isSingleton()) {          sharedInstance = getSingleton(beanName, () -> {            try {              return createBean(beanName, mbd, args);            }            catch (BeansException ex) {              destroySingleton(beanName);              throw ex;            }          });          bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);        }        else if (mbd.isPrototype()) {          // It's a prototype -> create a new instance.          Object prototypeInstance = null;          try {            beforePrototypeCreation(beanName);            prototypeInstance = createBean(beanName, mbd, args);          }          finally {            afterPrototypeCreation(beanName);          }          bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);        }        else {          String scopeName = mbd.getScope();          final Scope scope = this.scopes.get(scopeName);          if (scope == null) {            throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");          }          try {            Object scopedInstance = scope.get(beanName, () -> {              beforePrototypeCreation(beanName);              try {                return createBean(beanName, mbd, args);              }              finally {                afterPrototypeCreation(beanName);              }            });            bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);          }          catch (IllegalStateException ex) {            throw new BeanCreationException(beanName,                "Scope '" + scopeName + "' is not active for the current thread; consider " +                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",                ex);          }        }      }      catch (BeansException ex) {        cleanupAfterBeanCreationFailure(beanName);        throw ex;      }    }    省略........    return (T) bean;  }

咱们能够看到，该办法一进来会调用getSingleton办法从缓存获取实例，如果获取不到。会判断作用域是否为：单例，多列或者都不是，不同的作用域创立实例的规定不一样。接下来，咱们重点看一下getSingleton办法。

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

protected Object getSingleton(String beanName, boolean allowEarlyReference) {    Object singletonObject = this.singletonObjects.get(beanName);    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {      synchronized (this.singletonObjects) {        singletonObject = this.earlySingletonObjects.get(beanName);        if (singletonObject == null && allowEarlyReference) {          ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);          if (singletonFactory != null) {            singletonObject = singletonFactory.getObject();            this.earlySingletonObjects.put(beanName, singletonObject);            this.singletonFactories.remove(beanName);          }        }      }    }    return singletonObject;  }

咱们发现有三个Map汇合：

/** Cache of singleton objects: bean name --> bean instance */  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);  /** Cache of singleton factories: bean name --> ObjectFactory */  private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);  /** Cache of early singleton objects: bean name --> bean instance */  private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

singletonObjects对应一级缓存，earlySingletonObjects对应二级缓存，singletonFactories对应三级缓存。

下面getSingleton办法的逻辑是：

先从singletonObjects（一级缓存）中获取实例，如果能够获取到则间接返回singletonObject实例。
如果从singletonObjects（一级缓存）中获取不对实例，再从earlySingletonObjects（二级缓存）中获取实例，如果能够获取到则间接返回singletonObject实例。
如果从earlySingletonObjects（二级缓存）中获取不对实例，则从singletonFactories（三级缓存）中获取singletonFactory，如果获取到则调用getObject办法创立实例，把创立好的实例放到earlySingletonObjects（二级缓存）中，并且从singletonFactories（三级缓存）删除singletonFactory实例，而后返回singletonObject实例。
如果从singletonObjects、earlySingletonObjects和singletonFactories中都获取不到实例，则singletonObject对象为空。

获取实例须要调用applicationContext.getBean("xxx")办法，第一次调用getBean办法，代码走到getSingleton办法时返回的singletonObject对象是空的。而后接着往下执行，默认状况下bean的作用域是单例的，接下来咱们重点看看这段代码：

createBean办法会调用doCreateBean办法，该办法同样比拟长，咱们把不相干的代码省略掉。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)      throws BeanCreationException {    BeanWrapper instanceWrapper = null;    省略......        if (instanceWrapper == null) {      instanceWrapper = createBeanInstance(beanName, mbd, args);    }    final Object bean = instanceWrapper.getWrappedInstance();    省略........    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&        isSingletonCurrentlyInCreation(beanName));    if (earlySingletonExposure) {      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));    }    Object exposedObject = bean;    try {      populateBean(beanName, mbd, instanceWrapper);      exposedObject = initializeBean(beanName, exposedObject, mbd);    }    catch (Throwable ex) {      省略 .....    }    省略 .......    return exposedObject;  }

该办法的次要流程是：

创立bean实例
判断作用域是否为单例，容许循环依赖，并且以后bean正在创立，还没有创立实现。如果都满足条件，则调用addSingletonFactory将bean实例放入缓存中。
调用populateBean办法进行依赖注入
调用initializeBean办法实现对象初始化和AOP加强

咱们关注的重点能够先放到addSingletonFactory办法上。

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

该办法的逻辑是判断如果singletonObjects（一级缓存）中找不到实例，则将singletonFactory实例放到singletonFactories（三级缓存）中，并且移除earlySingletonObjects（二级缓存）中的实例。

createBean办法执行完之后，会调用外层的getSingleton办法

咱们重点看看这个getSingleton办法

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!)");        }        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) {          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;    }  }

该办法逻辑很简略，就是先从singletonObjects（一级缓存）中获取实例，如果获取不到，则调用singletonFactory.getObject()办法创立一个实例，而后调用addSingleton办法放入singletonObjects缓存中。

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

该办法会将实例放入singletonObjects（一级缓存），并且删除singletonFactories（二级缓存），这样当前再调用getBean时，都能从singletonObjects（一级缓存）中获取到实例了。

说了这么多，再回到示例中的场景。

spring为什么要用三级缓存，而不是二级缓存？

像示例的这种状况只用二级缓存是没有问题的。

然而如果有这种状况：a实例同时依赖于b实例和c实例，b实例又依赖于a实例，c实例也依赖于a实例。

a实例化时，先提前裸露objectFactorya到三级缓存，调用getBean(b)依赖注入b实例。b实例化之后，提前裸露objectFactoryb到三级缓存，调用getBean(a)依赖注入a实例，因为提前裸露了objectFactorya，此时能够从三级缓存中获取到a实例， b实例实现了依赖注入，降级为一级缓存。a实例化再getBean(c)依赖注入c实例，c实例化之后，提前裸露objectFactoryc到三级缓存，调用getBean(a)依赖注入a实例，因为提前裸露了objectFactorya，此时能够从三级缓存中获取到a实例。留神这里又要从三级缓存中获取a实例，咱们晓得三级缓存中的实例是通过调用singletonFactory.getObject()办法获取的，返回后果每次都可能不一样。如果不必二级缓存，这里会有问题，两次获取的a实例不一样。

总结：

只有单例的状况下能力解决循环依赖问题，并且allowCircularReferences要设置成true。

以下状况还是会呈现循环依赖：

结构器注入
作用域非单例的状况，当然在自定义作用域，本人能够实现防止循环依赖的逻辑
allowCircularReferences参数设置为false

大家喜爱这篇文章的话，烦请关注一下：苏三说技术