Bean的循环依赖问题

标签：依赖 name 对象 Bean 循环单例 public Husband

什么是Bean的循环依赖

Bean的循环依赖，就是A对象中有B属性，B对象中有A属性。即我依赖你，你也依赖我。也就是两个或多个对象之间相互引用成环。
比如：丈夫类Husband，妻子类Wife，Husband中有Wife的引用，Wife中有Husband的引用。

package cw.spring.bean;

/**
 * ClassName: Wife
 * Package: cw.spring.bean
 * Description:
 */
public class Wife {
    private String name;
    private Husband husband;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setHusband(Husband husband) {
        this.husband = husband;
    }
    
    @Override
    public String toString() {
        return "Wife{" + "name='" + name + '\'' + ", husband=" + husband.getName() + '}';
    }
}

package cw.spring.bean;

/**
 * ClassName: Husband
 * Package: cw.spring.bean
 * Description:
 */
public class Husband {
    private String name;
    private Wife wife;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setWife(Wife wife) {
        this.wife = wife;
    }
    
    @Override
    public String toString() {
        return "Husband{" + "name='" + name + '\'' + ", wife=" + wife.getName() + '}';
    }
}

单例模式 + set 注入

单例模式 + set 注入情况下的循环依赖

在单例模式 + set 注入的情况下，循环依赖是没有问题的，Spring 可以解决这个问题。

<bean id="husband" class="cw.spring.bean.Husband" scope="singleton">
  <property name="name" value="张三"/>
  <property name="wife" ref="wife"/>
</bean>
<bean id="wife" class="cw.spring.bean.Wife" scope="singleton">
  <property name="name" value="李四"/>
  <property name="husband" ref="husband"/>
</bean>

@org.junit.Test
public void test01() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    Husband husband = applicationContext.getBean("husband", Husband.class);
    Wife wife = applicationContext.getBean("wife", Wife.class);
    System.out.println(husband);
    System.out.println(wife);
}

分析单例模式 + set 注入情况下的循环依赖

在 set + singleton 模式下 Spring 对 Bean 的管理主要分为两个阶段：

- 第一个阶段：在 Spring 容器加载的时候，实例化 Bean，只要其中任意一个 Bean 实例化之后，马上进行“曝光”，不等属性赋值就曝光提前曝光，不等属性赋值就可以使用，因为单例下就只会创建该类型的对象一个，早曝光和晚曝光一样，都是这个对象
- 第二个阶段：Bean“曝光”之后，再进行属性的赋值，调用set方法。

解决单例模式 + set 注入情况下的循环依赖的核心解决方案是：实例化对象和对象的属性赋值分为两个阶段来完成的。
注意：只有在 scope 是 singleton 的情况下，Bean 才会采取提前“曝光”的措施。prototype 下不会进行提前曝光，如果多例模式下多个对象进行提前曝光，则Spring在使用对象的时候，不知道要使用哪个对象

多例模式 + set 注入

<bean id="husband" class="cw.spring.bean.Husband" scope="prototype">
  <property name="name" value="张三"/>
  <property name="wife" ref="wife"/>
</bean>
<bean id="wife" class="cw.spring.bean.Wife" scope="prototype">
  <property name="name" value="李四"/>
  <property name="husband" ref="husband"/>
</bean>

执行测试程序，发生了异常，异常信息如下：

当循环依赖的两个 bean 的 scope 都是 prototype 的时候，在 prototype + setter 模式下的循环依赖，存在问题，会出现异常 BeanCurrentlyInCreationException（当前的 Bean 正处于创建中异常）。因为都是多例模式，所以每次需要对象的时候都会new新的对象出来，A对象中需要B对象，会new一个新的B对象，B对象中需要A对象，会new一个新的A对象，新的A对象中需要B对象，会再new一个新的B对象......最终导致对象永远创建不完
如果其中任意一个是 singleton 的，就不会出现异常（因为单例模式下的 bean 实例化完成就会进行“曝光”，“曝光”后就可以停止死循环依赖）singleton 在解析配置文件时就创建对象，当需要 prototype对应的对象时可以马上创建一个 prototype 对象赋值给singleton，而 prototype 对象所需的 singleton 只有唯一的一个，从而可以让依赖停止下来，所以没有问题，prototype 对象和 singleton 对象的创建时机反过来也是类似。

单例模式 + 构造注入

单例模式 + 构造注入的方式下产生的循环依赖是无法解决的

package cw.spring.pojo;

/**
 * ClassName: Husband
 * Package: cw.spring.pojo
 * Description:
 */
public class Husband {
    private String name;
    private Wife wife;
    
    public Husband(String name, Wife wife) {
        this.name = name;
        this.wife = wife;
    }
    
    public String getName() {
        return name;
    }
    
    @Override
    public String toString() {
        return "Husband{" + "name='" + name + '\'' + ", wife=" + wife.getName() + '}';
    }
}

package cw.spring.pojo;

import cw.spring.bean.Husband;

/**
 * ClassName: Wife
 * Package: cw.spring.pojo
 * Description:
 */
public class Wife {
    private String name;
    private Husband husband;
    
    public Wife(String name, Husband husband) {
        this.name = name;
        this.husband = husband;
    }
    
    public String getName() {
        return name;
    }
    
    @Override
    public String toString() {
        return "Wife{" + "name='" + name + '\'' + ", husband=" + husband.getName() + '}';
    }
}

<!-- 默认情况下，Spring创建对象都是单例模式的 -->
<bean id="wife" class="cw.spring.pojo.Wife">
  <constructor-arg name="name" value="张三"/>
  <constructor-arg name="husband" ref="husband"/>
</bean>
<bean id="husband" class="cw.spring.pojo.Husband">
  <constructor-arg name="name" value="李四"/>
  <constructor-arg name="wife" ref="wife"/>
</bean>

@org.junit.Test
public void test01() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    Husband husband = applicationContext.getBean("husband", Husband.class);
    Wife wife = applicationContext.getBean("wife", Wife.class);
    System.out.println(husband);
    System.out.println(wife);
}

发生报错：Requested bean is currently in creation: Is there an unresolvable circular reference?（请求的bean当前正在创建中：是否存在无法解决的循环引用？）
基于构造注入的方式下产生的循环依赖是无法解决的，使用构造注入无法创建完对象马上进行曝光，因为创建对象需要另一个对象作为属性，无法完成对象的创建（类似死锁）
当创建A对象的时候，需要B对象，会马上进行B对象的创建，但是创建B对象又需要A对象，可是这个时候A对象还在创建中，导致B对象也无法完成创建，最终两个对象的创建都无法进行，使得创建对象和依赖注入失败基于构造注入的方式下产生的循环依赖是无法解决的，是由于构造方法注入会导致实例化对象的过程和对象属性赋值的过程没有分离开，必须在一起完成导致的。

Spring 解决循环依赖的机理（源码分析）

Spring 可以解决 set + singleton 模式下循环依赖：

根本的原因在于：这种方式可以做到将“实例化Bean”和“给Bean属性赋值”这两个动作分开去完成。
实例化Bean的时候：调用无参数构造方法来完成。此时可以先不给属性赋值，可以提前将该Bean对象“曝光”给外界。
给Bean属性赋值的时候：调用set方法来完成。
两个步骤是完全可以分离开去完成的，并且这两步不要求在同一个时间点上完成。也就是说，Bean都是单例的，我们可以先把所有的单例Bean实例化出来，放到一个集合当中（我们可以称之为缓存），所有的单例Bean全部实例化完成之后，以后我们再慢慢的调用setter方法给属性赋值。这样就解决了循环依赖的问题。

源码跟踪

- Spring 容器启动后，会执行 AbstractAutowireCapableBeanFactory 中的 doCreateBean 方法进行 Bean 的创建
- 这里对Bean进行缓存，缓存的是创建Bean的工厂对象，从而对Bean进行曝光，使得需要使用该Bean的对象可以获取该Bean

这里才是真正的给该bean的属性赋值

- addSingletonFactory为 DefaultSingletonBeanRegistry（默认单例Bean注册）类中的方法

- - 在 DefaultSingletonBeanRegistry类中有三个Map集合，即缓存Bean的三级缓存

- - - private final Map<String, Object> singletonObjects：一级缓存
    - private final Map<String, Object> earlySingletonObjects：二级缓存
    - private final Map<String, ObjectFactory<?>> singletonFactories：三级缓存

- - Map集合的key存储的都是bean的name（bean id）：

- - - 一级缓存存储的是：单例Bean对象。完整的单例Bean对象，也就是说这个缓存中的Bean对象的属性都已经赋值了。是一个完整的Bean对象。
    - 二级缓存存储的是：早期的单例Bean对象。这个缓存中的单例Bean对象的属性没有赋值。只是一个早期的实例对象。
    - 三级缓存存储的是：单例工厂对象。这个里面存储了大量的“工厂对象”，每一个单例Bean对象都会对应一个单例工厂对象。这个集合中存储的是，创建该单例对象时对应的那个单例工厂对象。

- 在这里使用put之后，相当于已经曝光了
- DefaultSingletonBeanRegistry 类中有 getSingleton 方法，用于获取单例 Bean 对象
- 从源码中可以看到，spring会先从一级缓存中获取Bean，如果获取不到，则从二级缓存中获取Bean，如果二级缓存还是获取不到，则从三级缓存中获取之前曝光的ObjectFactory对象，通过ObjectFactory对象获取Bean实例，这样就解决了循环依赖的问题。
- 缓存 Bean 对象之后，会在 AbstractAutowireCapableBeanFactory 中的 doCreateBean 方法中对 Bean 对象进行赋值

- - 单例Bean实例对象的创建和赋值过程分开，提前进行Bean曝光，解决循环依赖问题

- Spring只能解决set方法注入的单例bean之间的循环依赖。ClassA依赖ClassB，ClassB又依赖ClassA，形成依赖闭环。Spring在创建ClassA对象后，不需要等给属性赋值，直接将其曝光到bean缓存当中。在解析ClassA的属性时，又发现依赖于ClassB，再次去获取ClassB，当解析ClassB的属性时，又发现需要ClassA的属性，但此时的ClassA已经被提前曝光加入了正在创建的bean的缓存中，则无需创建新的的ClassA的实例，直接从缓存中获取即可。从而解决循环依赖问题。

面试常问：Spring 是如何解决循环依赖问题的？

关键就是提前暴露未完全创建完毕的 Bean。

在 Spring 中，只有同时满足以下两点才能解决循环依赖的问题
1. 依赖的 Bean 必须都是单例。
2. 依赖注入的方式，必须不全是构造器注入，且 beanName 字母序在前的不能是构造器注入。

标签：依赖,name,对象,Bean,循环,单例,public,Husband
From： https://blog.csdn.net/sanzailmn/article/details/141819304