spring 循环依赖的一次 理解

前言:

  在看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 标签的情况



注: 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


    


    

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,看了多次,总结的很好。

你可能感兴趣的:(spring 循环依赖的一次 理解)