Spring 是如何解决循环依赖的？

转
 2022-09-07
©版权
原文地址：https://blog.51cto.com/u_15683090/5410278

Spring 是如何解决循环依赖的？

循环依赖：

202209072234406381.png

Spring 循环依赖有三种情况：

  1. 构造器的循环依赖，这种依赖 Spring 无法处理，直接抛出 BeanCurrentlyInCreationException 异常
  2. 单例模式下的 setter 循环依赖，可以通过三级缓存处理
  3. 非单例循环依赖，无法处理,BeanCurrentlyInCreationException 异常

构造器循环依赖

正要创建的 bean 记录在缓存中，Spring 容器架构一个正在创建的 bean 标识符放在一个 “当前创建 bean 池”中国， 因此如果在创建 Bean 过程中，如果发现已经在当前创建的 Bean 池中，则抛出 BeanCurrentlyInCreationException 异常表示循环依赖，对于创建完毕的 Bean 将从“当前创建 Bean 池”中清除。 先看个例子：

    // StudentA 
    public class StudentA {
     
        private StudentB studentB ;
     
        public void setStudentB(StudentB studentB) {
            this.studentB = studentB;
        }
     
        public StudentA() {
        }
        
        public StudentA(StudentB studentB) {
            this.studentB = studentB;
        }
    }
    // StudentB 
    public class StudentB {
    
        private StudentC studentC ;
    
        public void setStudentC(StudentC studentC) {
            this.studentC = studentC;
        }
    
        public StudentB() {
        }
    
        public StudentB(StudentC studentC) {
            this.studentC = studentC;
        }
    }
    // StudentC
    public class StudentC {
    
        private StudentA studentA ;
    
        public void setStudentA(StudentA studentA) {
            this.studentA = studentA;
        }
    
        public StudentC() {
        }
    
        public StudentC(StudentA studentA) {
            this.studentA = studentA;
        }
    }

xml 配置

    <bean id="a" class="com.student.StudentA">
      <constructor-arg index="0" ref="b"></constructor-arg>
    </bean>
    <bean id="b" class="com.student.StudentB">
        <constructor-arg index="0" ref="c"></constructor-arg>
    </bean>
    <bean id="c" class="com.student.StudentC">
        <constructor-arg index="0" ref="a"></constructor-arg>
    </bean>

测试代码

    public class Test {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            //System.out.println(context.getBean("a", StudentA.class));
        }
    }

报错如下：

    caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: 
        Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

Setter 注入（单例）

    <!--scope="singleton"(默认就是单例方式)  -->
    <bean id="a" class="com.student.StudentA" scope="singleton">
     <property name="studentB" ref="b"></property>
    </bean>
    <bean id="b" class="com.student.StudentB" scope="singleton">
     <property name="studentC" ref="c"></property>
    </bean>
    <bean id="c" class="com.student.StudentC" scope="singleton">
     <property name="studentA" ref="a"></property>
    </bean>

测试代码

    public class Test {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            System.out.println(context.getBean("a", StudentA.class));
        }
    }

运行时不会报错的.

Setter 注入(非单例模式)

对于 prototype 作用域的 Bean ，Spring 容器无法完成依赖注入，因为 Prototype 作用域的bean ,sring 不进行缓冲，无法提提前暴露一个创建中的Bean。会抛出异常。

    <bean id="a" class="com.student.StudentA" scope="prototype">
     <property name="studentB" ref="b"></property>
    </bean>
    <bean id="b" class="com.student.StudentB" scope="prototype">
     <property name="studentC" ref="c"></property>
    </bean>
    <bean id="c" class="com.student.StudentC" scope="prototype">
     <property name="studentA" ref="a"></property>
    </bean>

测试代码

    public class Test {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            //System.out.println(context.getBean("a", StudentA.class));
        }
    }

报错

    Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: 
     Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

Spring Bean 创建过程

202209072234424692.png

  1. 实例化 Bean 对象，createBeanInstance 实例化
  2. 设置 Bean 属性，populateBean 填充属性
  3. 通过 各种 Aware 接口声明了依赖关系，则会注入 Bean 对容器基础设施层面的依赖，包括 BeanNameAware、BeanFactoryAware 和 ApplicationContextAware 分别注入 BeanID, BeanFactory 或者 ApplicationContext。
  4. 调用 BeanPostProcessor 的前置初始化方法 postProcessBeforeInitialization
  5. 如果实现了 InitializingBean 接口，会调用 afterProperties 方法。
  6. 调用 Bean 自定义的 init 方法，initializeBean 调用 xml 的 init方法
  7. 调用 BeanPostprocessor 的后缀初始方法 postProcessAfterInitialization。
  8. 创建过程完毕。

Spring 是如何解决单例的循环依赖问题的呢？

Spring 采用的三级缓存解决了单例的循环依赖问题。

三级缓存:

Spring 源码 DefaultSingletonBeanRegistry.java 中：

    /** Cache of singleton objects: bean name --> bean instance */
    一级缓存：维护着所有创建完成的Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
    
    /** Cache of early singleton objects: bean name --> bean instance */
    二级缓存：维护早期暴露的Bean(只进行了实例化，并未进行属性注入)
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
    
    /** Cache of singleton factories: bean name --> ObjectFactory */
    三级缓存：维护创建中Bean的ObjectFactory(解决循环依赖的关键)
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
    
    public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
      Assert.notNull(beanName, "'beanName' must not be null");
      synchronized (this.singletonObjects) {
       Object oldObject = this.singletonObjects.get(beanName);
       if (oldObject != null) {
        throw new IllegalStateException("Could not register object [" + singletonObject +
          "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
       }
          // 如果是新的bean 也会调用这个方法，这个方法是往一级缓存中set 值的 getSingleton()中也会调用
       addSingleton(beanName, singletonObject);
      }
     }
    /**
     * 添加单例实例
     * 解决循环引用的问题
     * Add the given singleton factory for building the specified singleton
     * if necessary.
     * <p>To be called for eager registration of singletons, e.g. to be able to
     * resolve circular references.
     * @param beanName the name of the bean
     * @param singletonFactory the factory for the singleton object
     */
    protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
     Assert.notNull(singletonFactory, "Singleton factory must not be null");
     synchronized (this.singletonObjects) {
      // 一级缓存实例化 bean 中不包含 正创建的 bean
      if (!this.singletonObjects.containsKey(beanName)) {
          // 三级缓存中添加
       this.singletonFactories.put(beanName, singletonFactory);
          // 二级缓冲删除
       this.earlySingletonObjects.remove(beanName);
       this.registeredSingletons.add(beanName);
      }
     }
    }

AbstractBeanFactory.doGetBean()

    protected  T doGetBean(final String name, @Nullable final Class requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
      
      // 尝试通过bean名称获取目标bean对象，比如这里的A对象
      Object sharedInstance = getSingleton(beanName);
      // 我们这里的目标对象都是单例的
      if (mbd.isSingleton()) {
        
        // 这里就尝试创建目标对象，第二个参数传的就是一个ObjectFactory类型的对象，这里是使用Java8的lamada
        // 表达式书写的，只要上面的getSingleton()方法返回值为空，则会调用这里的getSingleton()方法来创建
        // 目标对象
        sharedInstance = getSingleton(beanName, () -> {
          try {
            // 尝试创建目标对象
            return createBean(beanName, mbd, args);
          } catch (BeansException ex) {
            throw ex;
          }
        });
      }
      return (T) bean;
    }

getSingleton 可以这样理解：

  1. 先从一级缓冲中看有没有创建好的 bean ,有就直接返回。
  2. 如果没有，那么从二级缓存中看有没有创建 半成品的 Bean,如果有，直接返回
  3. 如果没有，从三级缓存中看下有没有创建过程中的 bean，还没有 那么通过 singletonFactory.getObject 最后到 createBean 创建。
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
      
      // 尝试从缓存中获取成品的目标对象，如果存在，则直接返回
      Object singletonObject = this.singletonObjects.get(beanName);
      
      // 如果缓存中不存在目标对象，则判断当前对象是否已经处于创建过程中，在前面的讲解中，第一次尝试获取A对象
      // 的实例之后，就会将A对象标记为正在创建中，因而最后再尝试获取A对象的时候，这里的if判断就会为true
      if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        
        synchronized (this.singletonObjects) {
          singletonObject = this.earlySingletonObjects.get(beanName);
          if (singletonObject == null && allowEarlyReference) {
            
            // 这里的singletonFactories是一个Map，其key是bean的名称，而值是一个ObjectFactory类型的
            // 对象，这里对于A和B而言，调用图其getObject()方法返回的就是A和B对象的实例，无论是否是半成品
            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
              
              // 获取目标对象的实例
              singletonObject = singletonFactory.getObject();
              this.earlySingletonObjects.put(beanName, singletonObject);
              this.singletonFactories.remove(beanName);
            }
          }
        }
      }
      return singletonObject;
    }

Spring 是怎么解决单例setter注入循环依赖的？

  • Spring是通过递归的方式获取目标bean及其所依赖的bean的；
  • Spring实例化一个bean的时候，是分两步进行的，首先实例化目标bean，然后为其注入属性

setter 注入是属性注入和构造器注入不一样，spring初始化是先创建bean ，然后注入属性的。单例 的setter采用三级缓存各自拿到各自的属性引用，然后再属性注入，最后各自完成实例化，不存在循环等待死锁的问题。

场景：A 依赖 B，B 依赖 A。

假设创建 A 对象的时候进入 getSingleton 方法。创建 B 的时候进入了个 doCreateBean 方法，在创建 B 还没创建完过程中，会在三级缓存 singletonFactories 先放一个 B，此时，如果创建 A 对象时，一级缓存没有B，从二级缓存找，二级缓存没有，从三级别缓存中找到就可以直接返回，并将自身A放入一级缓存中。

此时 B 在初始化过程中，从一级缓存中取到了A，这样B就拿到了A的引用，这样也B也就在拿到A的过程中完成了初始化。

    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {
      // 实例化当前尝试获取的bean对象，比如A对象和B对象都是在这里实例化的
      BeanWrapper instanceWrapper = null;
      if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
      }
      if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
      }
      // 判断Spring是否配置了支持提前暴露目标bean，也就是是否支持提前暴露半成品的bean
      boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences 
        && isSingletonCurrentlyInCreation(beanName));
      if (earlySingletonExposure) {
        
        // 如果支持，这里就会将当前生成的半成品的bean放到singletonFactories中，这个singletonFactories
        // 就是前面第一个getSingleton()方法中所使用到的singletonFactories属性，也就是说，这里就是
        // 封装半成品的bean的地方。而这里的getEarlyBeanReference()本质上是直接将放入的第三个参数，也就是
        // 目标bean直接返回
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
      }
      try {
        // 在初始化实例之后，这里就是判断当前bean是否依赖了其他的bean，如果依赖了，
        // 就会递归的调用getBean()方法尝试获取目标bean
        populateBean(beanName, mbd, instanceWrapper);
      } catch (Throwable ex) {
        // 省略...
      }
      return exposedObject;
    }