spring的循环依赖

uuboke

已于 2023-07-02 20:22:52 修改

阅读量783

点赞数 2

分类专栏： spring 文章标签： java

于 2020-11-08 11:15:45 首次发布

本文链接：https://blog.csdn.net/wojiao228925661/article/details/109549165

版权

spring 专栏收录该内容

9 篇文章

订阅专栏

1、介绍几个概念

官网：Redirecting...

循环依赖

spring循环依赖解决不了构造器注入的
我们AB循环依赖问题只要A的注入方式是setter且singleton，就不会有循环依赖的问题。
默认的单例（singleton）的场景是支持循环依赖的，不报错
原型（prototype）的场景是不支持循环依赖的，会报错（因为spring是依靠三级缓存来解决循环依赖的，而原型是每次都创建一个新的对象，不会保存在缓存中）

只有单例的bean会通过三级缓存提前暴露来解决循环依赖的问题，而非单例的bean，每次从容器中获取都是一个新的对象，都会重新创建，所以非单例的bean是没有缓存的，不会将其放到三级缓存中
DefaultSingletonBeanRegistry

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

   /**
    * Internal marker for a null singleton object:
    * used as marker value for concurrent Maps (which don't support null values).
    */
   protected static final Object NULL_OBJECT = new Object();


   /** Logger available to subclasses */
   protected final Log logger = LogFactory.getLog(getClass());

   /** Cache of singleton objects: bean name --> bean instance */
   // 一级缓存，缓存的是创建的bean实例
   // 单例对象的缓存：bean 名称-bean实例，即所谓的单例池;表示已经经历了完整的生命周期的bean对象
   private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

   /** Cache of singleton factories: bean name --> ObjectFactory */
   // 三级缓存，它缓存的对象是ObjectFetcory，这个是个匿名内部类，
   // 在解决循环依赖很重要，保持前后创建的对象是一致的，代理类或者常规类
   // 单例工厂的高速缓存：bean名称--objectFactory
   // 表示存放生成bean的工厂
   private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

   /** Cache of early singleton objects: bean name --> bean instance */
   // 二级缓存，它缓存的是还在创建过程中的对象
   // 早期的单例对象的高速缓存：bean名称 -- bean实例
   // 表示bean的生命周期还没有走完(bean的属性还未填充)就把这个bean存入该缓存中
   // 也就是实例化但未初始化的bean放入该缓存里
   private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
}

循环依赖比较重要的代码

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   if (logger.isDebugEnabled()) {
      logger.debug("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
   }
   // 给缓存里面添加
   addSingletonFactory(beanName, new ObjectFactory<Object>() {
      @Override
      public Object getObject() throws BeansException {
          // 回调
         return getEarlyBeanReference(beanName, mbd, bean);
      }
   });
}


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

下图是B创建完毕是，向一级缓存加数据的截图：

1、a创建过程中需要b，于是a将自己放到三级缓存里面，去实例化b
2、b实例化的时候发现需要a，于是b先查一级缓存，没有，再查询二级缓存，还是没有，再查三级缓存，找到了a，然后三级缓存里面的这个a放到二级缓存里面，并删除三级缓存里面的a
3、b顺利初始化完毕，将自己放到一级缓存里面（此时b里面的a依然事创建中状态），然后回来接着创建a，此时b已经创建结束，直接从一级缓存里面拿到b，然后完成创建，并将a自己放到一级缓存里面

循环依赖：（下面都是我看代码自己的见解）

1、首先是创建对象A，在创建完对象，给属性赋值的时候，由于要给B属性赋值（A还没有进行初始化工作，在赋值之前会把创建的A对象放到三级缓存中，缓存的是一个匿名内部类，这个内部类调用的时机是B给属性赋值的时候）

2、创建对象B，在创建完对象，给属性赋值的时候，由于要给A属性赋值（赋值之前会把创建的B对象放到三级缓存中，回调缓存在三级缓存的A的匿名对象，执行对象的创建过程（可能是代理类哦）），并初始化，保存在一级缓存中

A正在被创建，并赋值

3、给A对象赋值，并初始化，保存在一级缓存中

循环依赖
Spring解决循环依赖依靠的是bean的"中间态"这个概念，而这个中间态指的是已经实例化但还没有初始化但状态--》半成品。实例化但过程又是通过构造器创建但，如果A还没有创建好出来怎么可能提前暴露，所以构造器但循环依赖无法解决。假设A、B循环引用，实例化A的时候就将其放入到三级缓存中，接着填充属性的时候，发现依赖了B，同样的流程也是实例化后放入三级缓存，接着去填充属性时又发现自己依赖A，这时从缓存中查找到早期暴露的A，没有AOP代理的话，直接将A的原始对象注入B，完成B的初始化后，进行属性填充和初始化，这时候B完成后，就去完成剩下的A的步骤，如果又AOP处理获取代理后的对象A，注入B，后剩下的流程


1、调用doGetBean方法，想要获取beanA，于是调用getSingleton方法从缓存中查找beanA 2、在getSinglton方法中，从一级缓存中查找，没有，返回null 3、doGetBean方法中获取到的beanA为null，于是走对应的处理逻辑，调用getSingleton的重载方法(参数为objectFactory) 4、在getSingleton方法中，先将beanA_name添加到一个集合中，用于标记该bean正在创建中，然后回调匿名类部类的createBean方法 5、进入AbstractAutowireCapableBeanFactory#doCreateBean，先反射调用构造器创建出beanA的实例，然后判断：是否是单例、是否允许提前暴露引用(对于单例的一般为true)、是否正在创建中(即是否在第四部的集合中)。判断为true则将beanA添加到【三级缓存】中 6、对beanA进行属性填充，此时检测beanA依赖于beanB，于是开始查找beanB 7、调用doGetBean方法，和上面的beanA的过程一样，到缓存中查找beanB，没有则创建，然后给beanB填充属性 8、此时beanB依赖于beanA，调用getSingleton获取beanA，依此从一级、二级、三级缓存中赵，此时从三级缓存中获取到beanA的创建工厂，通过创建工厂获取singletonObject，此时这个singletonObject指向的就是上面在doGreateBean方法中实例化的beanA 9、这样beanB就获取到了beanA的依赖，于是beanB顺利完成实例化，并将beanA从三级缓存移动到二级缓存中 10、随后beanA继续他的属性填充工作，此时也获取到了beanB，beanA也随之完成了创建，回到getSgingleton方法中继续向下执行，将beanA从二级缓存移动到一级缓存中