首页 > 其他分享> > spring 循环依赖的一次理解

spring 循环依赖的一次理解

2019-07-28 22:00:09 作者：互联网

前言：

　　在看spring 循环依赖的问题中，知道原理，网上一堆的资料有讲原理。但今天在看代码过程中，又产生了疑问。疑问点如下：

// 疑问点： 先进行 dependon 判断
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
   for (String dep : dependsOn) {
      if (isDependent(beanName, dep)) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
      }
      registerDependentBean(dep, beanName);
      try {
         getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
      }
   }
}

// 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;
      }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

　　想着这里先会判断是否有依赖， bean 提前曝光的代码在检查依赖的后面，那循环依赖，不就进入死循环了吗？是否有统统疑问的朋友～～～ --也不知道当时这么想的，只能说还有提高的空间。心想不对，写了简单的demo，开始debug了。　　结论：这里的 mbd.getDependsOn() 只有在配置了 depend-on 标签的时候，才会解析，有值。！！！这也是导致理解循环依赖有问题的关键。这里先简单记录下现在理解的循环依赖的大致流程： 1、depende-on 标签的情况

<bean id="aService" class="com.zzf.spring.dependent.AService" depends-on="bService"/>
<bean id="bService" class="com.zzf.spring.dependent.BService" depends-on="aService"/>

注： depends-on适用于表面上看起来两个bean之间没有使用属性之类的强连接的bean，但是两个bean又确实存在前后依赖关系的情况，使用了depends-on的时候，依赖他人的bean是先于被依赖bean销毁的。一般不会这么使用。

也就是这样配置的情况，才会抛出 BeanCreationException 异常。

if (isDependent(beanName, dep)) {// 判断返回 true， 抛出循环依赖的exception
   throw new BeanCreationException(mbd.getResourceDescription(), beanName,
         "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}

2、正确的 xml 配置的循环依赖 demo

<bean id="aService" class="com.zzf.spring.dependent.AService">
    <property name="bService" ref="bService"/>
</bean>
<bean id="bService" class="com.zzf.spring.dependent.BService">
    <property name="aService" ref="aService"/>
</bean>

　　3、注解的方式解决循环依赖

@Service
public class Aservice {
    @Autowired
    private BService service;
}

@Service
public class BService {
    @Autowired
    private Aservice aservice;
}

都说这段是解决循环依赖的关键所在：

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

　　这里主要涉及到3个缓存， singletonObjects，earlySingletonObjects， singletonFactories。

singletonObjects：单例对象的 cache

singletonFactories：单例对象工厂的 cache

earlySingletonObjects：提前曝光的单例对象的 cache。（这是关键）

这里只考虑 A--B --A的情况：

Object sharedInstance = getSingleton(beanName);

　　第一次 getBean(A)的时候，返回是 null，会走如下流程：

// 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;
      }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

　　在 createBean -> doCreate中有如下： addSingletonFactory（）提前曝光当前类工厂，到 singletonFactory中

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");
   }
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

　　然后执行 protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) 进行属性的赋值。在进行 B的属性赋值中，发现B还没有初始化，则会去调用 BeadFactory.getBean(B) 进行 B的初始化。

　　调用B的过程中，和A类似，也会提前在singletonFactory 中曝光，然后在 populateBean 中，注入 A属性值时，因为A未初始化，再次去请求 getBean（A), 这次在 getSingleton（）中，因为 A提前曝光，所以在getSingleton 中返回 A（可能未完全初始化），最终调用 getObjectForBeanInstance 方法，返回完全实例话的 bean A，然后注入到B 中，并完成B的初始化， bean都会放进singletonObjects 缓存中。

　　TODO：在 populateBean 中怎么检测到 properties，这块还需仔细的去debug，还没完全理清楚。

参考资料：http://cmsblogs.com/?p=2887，看了多次，总结的很好。

标签：依赖,mbd,spring,beanName,dep,bean,循环,singletonObject
来源： https://www.cnblogs.com/idea-persistence/p/11261098.html

spring 循环依赖的一次 理解

前言：

spring 循环依赖的一次理解