Spring 是如何解决循环依赖的？
循环依赖：
Spring 循环依赖有三种情况：
- 构造器的循环依赖，这种依赖 Spring 无法处理，直接抛出 BeanCurrentlyInCreationException 异常
- 单例模式下的 setter 循环依赖，可以通过三级缓存处理
- 非单例循环依赖，无法处理,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 创建过程
- 实例化 Bean 对象，createBeanInstance 实例化
- 设置 Bean 属性，populateBean 填充属性
- 通过 各种 Aware 接口声明了依赖关系，则会注入 Bean 对容器基础设施层面的依赖，包括 BeanNameAware、BeanFactoryAware 和 ApplicationContextAware 分别注入 BeanID, BeanFactory 或者 ApplicationContext。
- 调用 BeanPostProcessor 的前置初始化方法 postProcessBeforeInitialization
- 如果实现了 InitializingBean 接口，会调用 afterProperties 方法。
- 调用 Bean 自定义的 init 方法，initializeBean 调用 xml 的 init方法
- 调用 BeanPostprocessor 的后缀初始方法 postProcessAfterInitialization。
- 创建过程完毕。
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 可以这样理解：
- 先从一级缓冲中看有没有创建好的 bean ,有就直接返回。
- 如果没有，那么从二级缓存中看有没有创建 半成品的 Bean,如果有，直接返回
- 如果没有，从三级缓存中看下有没有创建过程中的 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; }
