Spring的循环依赖

什么是循环依赖

多个bean之间相互依赖，形成了一个闭环。 比如:A依赖于B、B依赖于c、c依赖于A

通常来说，如果问spring容器内部如何解决循环依赖， 一定是指默认的单例Bean中，属性互相引用的场景

也就是说，Spring的循环依赖，是Spring容器注入时候出现的问题

两种注入方式对循环依赖的影响

循环依赖官网说明

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans

结论

我们AB循环依赖问题只要A的注入方式是setter且singleton, 就不会有循环依赖问题

spring容器循环依赖报错演示BeanCurrentlylnCreationException

循环依赖现象在Spring容器中 注入依赖的对象，有2种情况

构造器方式注入依赖

code

ServiceA

import org.springframework.stereotype.Component;

@Component
public class ServiceA {

    private ServiceB serviceB;

    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

ServiceB

import org.springframework.stereotype.Component;

@Component
public class ServiceB {

    private ServiceA serviceA;

    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

ClientConstructor

/**
 * 通过构造器的方式注入依赖，构造器的方式注入依赖的bean，下面两个bean循环依赖
 *
 * 测试后发现，构造器循环依赖是无法解决的
 */
public class ClientConstructor {
    public static void main(String[] args) {
        new ServiceA(new ServiceB(new ServiceA(new ServiceB()))); ....
    }
}

结论

构造器注入没有办法解决循环依赖， 你想让构造器注入支持循环依赖，是不存在的

以set方式注入依赖

code

ServiceA

import org.springframework.stereotype.Component;

@Component
public class ServiceA {

    private ServiceB serviceB;

    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
        System.out.println("A 里面设置了B");
    }
}

ServiceB

import org.springframework.stereotype.Component;

@Component
public class ServiceB {

    private ServiceA serviceA;

    public void setServiceA(ServiceA serviceA) {
        this.serviceA = serviceA;
        System.out.println("B 里面设置了A");
    }
}

ClientSet

public class ClientSet {
    public static void main(String[] args) {
        //创建serviceA
        ServiceA serviceA = new ServiceA();

        //创建serviceB
        ServiceB serviceB = new ServiceB();

        //将serviceA注入到serviceB中
        serviceB.setServiceA(serviceA);

        //将serviceB注入到serviceA中
        serviceA.setServiceB(serviceB);
    }
}

spring容器

• 默认的单例(singleton)的场景是支持循环依赖的，不报错
• 原型(Prototype)的场景是不支持循环依赖的，报错

步骤

• applicationContext.xml

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
                             http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/context
                             http://www.springframework.org/schema/context/spring-context.xsd
                             http://www.springframework.org/schema/aop
                             http://www.springframework.org/schema/aop/spring-aop.xsd
                             http://www.springframework.org/schema/tx
                             http://www.springframework.org/schema/tx/spring-tx.xsd">
  
      <!--
          1.spring容器默认的单例模式可以解决循环引用，单例默认支持
          2.spring容器原型依赖模式scope="prototype"多例模式下不能解决循环引用
      -->
  
      <!--depends-on 的意思就是当前这个bean如果要完成，先看depends-on指定的bean是否已经完成了初始化-->
      <!--scope="prototype"代表每次都要新建一次对象-->
  
  
      <bean id="a" class="com.hhf.study.spring.circulardepend.A" >
          <property name="b" ref="b"/>
      </bean>
  
      <bean id="b" class="com.hhf.study.spring.circulardepend.B">
          <property name="a" ref="a"/>
      </bean>
  </beans>

• log4j.properties

  ### 设置###
  log4j.rootLogger = debug,stdout,D,E
  
  ### 输出信息到控制抬 ###
  log4j.appender.stdout = org.apache.log4j.ConsoleAppender
  log4j.appender.stdout.Target = System.out
  log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
  log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
  
  ### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
  log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
  log4j.appender.D.File = E://logs/log.log
  log4j.appender.D.Append = true
  log4j.appender.D.Threshold = DEBUG 
  log4j.appender.D.layout = org.apache.log4j.PatternLayout
  log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
  
  ### 输出ERROR 级别以上的日志到=E://logs/error.log ###
  log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
  log4j.appender.E.File =E://logs/error.log 
  log4j.appender.E.Append = true
  log4j.appender.E.Threshold = ERROR 
  log4j.appender.E.layout = org.apache.log4j.PatternLayout
  log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r

• 默认单例，修改为原型scope=”prototype” 就导致了循环依赖错误

• ClientSpringContainer

  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  /**
   * nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException:
   * Error creating bean with name 'a': 578624778
   * Requested bean is currently in creation: Is there an unresolvable circular reference?
   *
   *
   * 只有单例的bean会通过三级缓存提前暴露来解决循环依赖的问题，因为单例的时候只有一份，随时复用，那么就放到缓存里面
   * 而多例的bean，每次从容器中荻取都是—个新的对象，都会重B新创建， 
   * 所以非单例的bean是没有缓存的，不会将其放到三级缓存中。
   */
  public class ClientSpringContainer {
      public static void main(String[] args) {
          ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
          A a = context.getBean("a",A.class);
          B b = context.getBean("b",B.class);
      }
  }

• 循环依赖异常

  

重要结论(spring内部通过3级缓存来解决循环依赖)

DefaultSingletonBeanRegistry

第一级缓存〈也叫单例池）singletonObjects:存放已经经历了完整生命周期的Bean对象

第二级缓存: earlySingletonObjects，存放早期暴露出来的Bean对象，Bean的生命周期未结束（属性还未填充完整）

第三级缓存: Map<String, ObiectFactory<?>> singletonFactories，存放可以生成Bean的工厂

所谓的三级缓存其实就是spring容器内部用来解决循环依赖问题的三个map

循环依赖Debug

实例化/初始化

实例化:堆内存中申请一块内存空间

初始化属性填充:完成属性的各种赋值

3大Map和四大方法，总体相关对象

三级缓存+四大方法

1.getSingleton：希望从容器里面获得单例的bean，没有的话

2.doCreateBean: 没有就创建bean

3.populateBean: 创建完了以后，要填充属性

4.addSingleton: 填充完了以后，再添加到容器进行使用

第一层singletonObjects存放的是已经初始化好了的Bean,

第二层earlySingletonObjects存放的是实例化了，但是未初始化的Bean,

第三层singletonFactories存放的是FactoryBean。假如A类实现了FactoryBean,那么依赖注入的时候不是A类，而是A类产生的Bean

A/B两对象在三级缓存中的迁移说明

1 A创建过程中需要B，于是A将自己放到三级缓存里面，去实例化B

2 B实例化的时候发现需要A，于是B先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了A
然后把三级缓存里面的这个A放到二级缓存里面，并删除三级缓存里面的A

3 B顺利初始化完毕，将自己放到一级缓存里面（此时B里面的A依然是创建中状态）
然后回来接着创建A，此时B已经创建结束，直接从一级缓存里面拿到B，然后完成创建，并将A自己放到一级缓存里面。

总结spring是如何解决的循环依赖?

Spring创建bean主要分为两个步骤，创建原始bean对象，接着去填充对象属性和初始化
每次创建bean之前，我们都会从缓存中查下有没有该bean，因为是单例，只能有一个
当我们创建 beanA的原始对象后，并把它放到三级缓存中，接下来就该填充对象属性了，这时候发现依赖了beanB，接着就又去创建beanB，同样的流程，创建完 beanB填充属性时又发现它依赖了beanA又是同样的流程，不同的是：这时候可以在三级缓存中查到刚放进去的原始对象beanA，所以不需要继续创建，用它注入beanB，完成beanB的创建
既然 beanB创建好了，所以beanA就可以完成填充属性的步骤了，接着执行剩下的逻辑，闭环完成

spring解决循环依赖的整个流程图

Debug的步骤—->Spring解决循环依赖过程

1. 调用doGetBean()方法，想要获取beanA，于是调用getSingleton()方法从缓存中查找beanA
2. 在getSingleton()方法中，从一级缓存中查找，没有，返回null
3. doGetBean()方法中获取到的beanA为null，于是走对应的处理逻辑，调用getSingleton()的重载方法（参数为ObjectFactory的)
4. 在getSingleton()方法中，先将beanA_name添加到一个集合中，用于标记该bean正在创建中。然后回调匿名内部类的creatBean方法
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指向的就是上面在doCreateBean()方法中实例化的beanA
9. 这样beanB就获取到了beanA的依赖，于是beanB顺利完成实例化，并将beanA从三级缓存移动到二级缓存中
10. 随后beanA继续他的属性填充工作，此时也获取到了beanB，beanA也随之完成了创建，回到getsingleton()方法中继续向下执行，将beanA从二级缓存移动到一级缓存中

赏

Thanks

支付宝

微信