Spring中的循环依赖解决详解

最新推荐文章于 2024-07-22 22:39:54 发布

mocas_wang

最新推荐文章于 2024-07-22 22:39:54 发布

阅读量1.9k

点赞数 3

分类专栏： Spring生态

本文链接：https://blog.csdn.net/mocas_wang/article/details/118407222

版权

Spring生态专栏收录该内容

16 篇文章 1 订阅

订阅专栏

1 什么是循环依赖？

循环依赖就是循环引用，指两个或多个bean互相持有对方，比如说TestA引用TestB、TestB引用TestA，最终形成一个闭环。

注意：循环依赖不是指循环调用。

从字面上来理解就是A依赖B的同时B也依赖了A，就像下面这样

循环调用：指方法之间的环调用，循环调用是无解的，除非有终结条件，否则就是死循环，最终会导致内存溢出异常。

两种Spring容器循环依赖：

构造器循环依赖
setter方法循环依赖

体现到代码层次就是这个样子

1.1 构造器循环依赖

@Service
public class A {  
    public A(B b) {  }
}

@Service
public class B {  
    public B(C c) {  
    }
}

@Service
public class C {  
    public C(A a) {  }
}

结果：项目启动失败，发现了一个cycle

1.2 field属性注入循环依赖

@Service
public class A1 {  
    @Autowired  
    private B1 b1;
}

@Service
public class B1 {  
    @Autowired  
    public C1 c1;
}

@Service
public class C1 {  
    @Autowired  public A1 a1;
}

结果：项目启动成功

1.3 field属性注入循环依赖（prototype）

@Service
@Scope("prototype")
public class A1 {  
    @Autowired  
    private B1 b1;
}

@Service
@Scope("prototype")
public class B1 {  
    @Autowired  
    public C1 c1;
}

@Service
@Scope("prototype")
public class C1 {  
    @Autowired  public A1 a1;
}

结果：项目启动失败，发现了一个cycle。

现象总结：同样对于循环依赖的场景，构造器注入和prototype类型的属性注入都会初始化Bean失败。因为@Service默认是单例的，所以单例的属性注入是可以成功的

2 循环依赖处理

2.1　构造器循环依赖（无法解决）

表示通过构造器注入构成的循环依赖，此依赖是无解的，强行依赖只能抛出异常（BeanCreationException）；

Spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池”中，bean标识符在创建过程中将一直保持在这个池中，因此在创建bean的过程中如果发现自己已经在池中，则抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的bean将从“当前创建bean池”中清除掉。

下面我们通过一段代码来印证上述理论。

创建application.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">
 
    <bean id="testA" class="com.chenpt.springFrameWork.TestA">
        <constructor-arg name="testB" ref="testB"></constructor-arg>
    </bean>
 
    <bean id="testB" class="com.chenpt.springFrameWork.TestB">
        <constructor-arg name="testA" ref="testA"></constructor-arg>
    </bean>
 
</beans>

客户端测试用例：

public class MainTest {
    public static void main(String[] args){
        ApplicationContext context = new FileSystemXmlApplicationContext("classpath:spring/applicationContext.xml");
 
    }
}

　执行结果如下图（仅截了部分错误）

2.2 setter循环依赖（可以解决）

指通过setter注入方式构成的循环依赖。

解决方式：Spring容器提前暴露刚完成构造器注入但未完成其他步骤（如setter注入）的bean来完成的。而且只能解决单例作用域的bean循环依赖。通过提前暴露一个单例工厂方法，从而使其他bean能引用到该bean。

代码示例：

首先需要去掉构造器注入的参数。

//bean1
public class TestA {
    private TestB testB;
 
    TestA(){}
 
    public TestB getTestB() {
        return testB;
    }
 
    public void setTestB(TestB testB) {
        this.testB = testB;
    }
}
//bean2
public class TestB {
    private TestA testA;
 
    TestB(){}
 
    public TestA getTestA() {
        return testA;
    }
 
    public void setTestA(TestA testA) {
        this.testA = testA;
    }
}

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">
 
    <bean id="testA" class="com.chenpt.springFrameWork.TestA" scope="singleton">
        <property name="testB" ref="testB"/>
    </bean>
 
    <bean id="testB" class="com.chenpt.springFrameWork.TestB" scope="singleton">
        <property name="testA" ref="testA"/>
    </bean>
 
</beans>

客户端执行（自行演示，无输出错误）

2.3 prototype范围的依赖处理（无法解决）

对于prototype作用域bean，spring容器无法完成依赖注入，因为spring容器不进行缓存prototype作用域的bean，因此无法提前暴露一个正在创建中的bean。

示例代码如下：

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">
 
    <bean id="testA" class="com.chenpt.springFrameWork.TestA" scope="prototype">
        <property name="testB" ref="testB"/>
    </bean>
 
    <bean id="testB" class="com.chenpt.springFrameWork.TestB" scope="prototype">
        <property name="testA" ref="testA"/>
    </bean>
 
</beans>

客户端示例

public class MainTest {
    public static void main(String[] args){
        ApplicationContext context = new FileSystemXmlApplicationContext("classpath:spring/applicationContext.xml");
 
        TestB testB = context.getBean("testB",TestB.class);
    }
}

执行结果，抛出异常

针对上述的作用域（scope）分析

beanFactory除了拥有ioc的职责外，还有着对象生命周期管理。

scope用来声明容器中对象所应该处的限定场景或者该对象的存活时间，即容器在对象进入其相应的scope之前，生成并装配这些对象，在对象不再处于scope的限定之后，容器通常会销毁这些对象。

spring容器提供了几种scope类型？

singleton：在spring容器中只存在一个实例，所有对象的引用将共享这个实例。（注：不要和单例模式搞混）
prototype：容器每次都会生成一个新的对象实例给请求方。
request （限定在web应用中使用）：为每个http请求创建一个全新的request-processor对象供当前请求使用，请求结束，实例生命周期即结束。
session （限定在web应用中使用）：为每个独立的session创建一个全新的UserPreference对象实例。
global session （限定在web应用中使用）：只有应用在基于portlet的Web应用程序中才有意义，它映射到portlet的global范围的session。如果在普通的基于servlet的Web应用中使用了这个类型的scope，容器会将其作为普通的session类型的scope对待。

下面主要说明第二种情况中循环依赖的解决方案

　　步骤一：beanA进行初始化，并且将自己进行初始化的状态记录下来，并提前向外暴露一个单例工程方法，从而使其他bean能引用到该bean（可能读完这一句，您仍然心存疑惑，没关系，继续往下读）

　　步骤二：beanA中有beanB的依赖，于是开始初始化beanB。

　　步骤三：初始化beanB的过程中又发现beanB依赖了beanA,于是又进行beanA的初始化，这时发现beanA已经在进行初始化了，程序发现了存在的循环依赖，然后通过步骤一中暴露的单例工程方法拿到beanA的引用（注意，此时的beanA只是完成了构造函数的注入但为完成其他步骤），从而beanB拿到beanA的引用，完成注入，完成了初始化，如此beanB的引用也就可以被beanA拿到，从而beanA也就完成了初始化。

　　spring进行bean的加载的时候，首先进行bean的初始化（调用构造函数），然后进行属性填充。在这两步中间，spring对bean进行了一次状态的记录，也就是说spring会把指向只完成了构造函数初始化的bean的引用通过一个变量记录下来，明白这一点对之后的源码理解至关重要。

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

关于循环依赖的解决方式应该要分两种情况来讨论

简单的循环依赖（没有AOP）
结合了AOP的循环依赖

简单的循环依赖（没有AOP）

首先，我们要知道Spring在创建Bean的时候默认是按照自然排序来进行创建的，所以第一步Spring会去创建A。

与此同时，我们应该知道，Spring在创建Bean的过程中分为三步

实例化，对应方法：AbstractAutowireCapableBeanFactory中的createBeanInstance方法
属性注入，对应方法：AbstractAutowireCapableBeanFactory的populateBean方法
初始化，对应方法：AbstractAutowireCapableBeanFactory的initializeBean

实例化，简单理解就是new了一个对象
属性注入，为实例化中new出来的对象填充属性
初始化，执行aware接口中的方法，初始化方法，完成AOP代理

从上图中我们可以看到，虽然在创建B时会提前给B注入了一个还未初始化的A对象，但是在创建A的流程中一直使用的是注入到B中的A对象的引用，之后会根据这个引用对A进行初始化，所以这是没有问题的。

结合了AOP的循环依赖

在给B注入的时候为什么要注入一个代理对象？

答：当我们对A进行了AOP代理时，说明我们希望从容器中获取到的就是A代理后的对象而不是A本身，因此把A当作依赖进行注入时也要注入它的代理对象

明明初始化的时候是A对象，那么Spring是在哪里将代理对象放入到容器中的呢？

在完成初始化后，Spring又调用了一次getSingleton方法，这一次传入的参数又不一样了，false可以理解为禁用三级缓存，前面图中已经提到过了，在为B中注入A时已经将三级缓存中的工厂取出，并从工厂中获取到了一个对象放入到了二级缓存中，所以这里的这个getSingleton方法做的时间就是从二级缓存中获取到这个代理后的A对象。exposedObject == bean可以认为是必定成立的，除非你非要在初始化阶段的后置处理器中替换掉正常流程中的Bean，例如增加一个后置处理器：

@Component
public class MyPostProcessor implements BeanPostProcessor {
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (beanName.equals("a")) {
			return new A();
		}
		return bean;
	}
}

不过，请不要做这种骚操作，徒增烦恼！

初始化的时候是对A对象本身进行初始化，而容器中以及注入到B中的都是代理对象，这样不会有问题吗？

答：不会，这是因为不管是cglib代理还是jdk动态代理生成的代理类，内部都持有一个目标类的引用，当调用代理对象的方法时，实际会去调用目标对象的方法，A完成初始化相当于代理对象自身也完成了初始化

三级缓存为什么要使用工厂而不是直接使用引用？换而言之，为什么需要这个三级缓存，直接通过二级缓存暴露一个引用不行吗？

答：这个工厂的目的在于延迟对实例化阶段生成的对象的代理，只有真正发生循环依赖的时候，才去提前生成代理对象，否则只会创建一个工厂并将其放入到三级缓存中，但是不会去通过这个工厂去真正创建对象

4 面试答案

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

答：Spring通过三级缓存解决了循环依赖，其中一级缓存为单例池（singletonObjects）,二级缓存为早期曝光对象earlySingletonObjects，三级缓存为早期曝光对象工厂（singletonFactories）。当A、B两个类发生循环引用时，在A完成实例化后，就使用实例化后的对象去创建一个对象工厂，并添加到三级缓存中，如果A被AOP代理，那么通过这个工厂获取到的就是A代理后的对象，如果A没有被AOP代理，那么这个工厂获取到的就是A实例化的对象。当A进行属性注入时，会去创建B，同时B又依赖了A，所以创建B的同时又会去调用getBean(a)来获取需要的依赖，此时的getBean(a)会从缓存中获取，第一步，先获取到三级缓存中的工厂；第二步，调用对象工工厂的getObject方法来获取到对应的对象，得到这个对象后将其注入到B中。紧接着B会走完它的生命周期流程，包括初始化、后置处理器等。当B创建完后，会将B再注入到A中，此时A再完成它的整个生命周期。至此，循环依赖结束！

面试官：”为什么要使用三级缓存呢？二级缓存能解决循环依赖吗？“

答：如果要使用二级缓存解决循环依赖，意味着所有Bean在实例化后就要完成AOP代理，这样违背了Spring设计的原则，Spring在设计之初就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来在Bean生命周期的最后一步来完成AOP代理，而不是在实例化后就立马进行AOP代理。

mocas_wang

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
2
评论
Spring中的循环依赖解决详解

目录1 什么是循环依赖？1.1 构造器循环依赖1.2 field属性注入循环依赖1.3 field属性注入循环依赖（prototype）2 循环依赖处理2.1　构造器循环依赖（无法解决）2.2 setter循环依赖（可以解决）2.3 prototype范围的依赖处理（无法解决）3 Spring是如何解决的循环依赖？简单的循环依赖（没有AOP）结合了AOP的循环依赖4 面试答案1 什么是循环依赖？循环依赖就是循环引用，指两个或多个bean互相持有对方，.
复制链接

扫一扫