ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java框架 —— Spring（循环依赖问题） [打印本页]
作者: 北冰洋以北    时间: 2024-12-12 14:42
标题: Java框架 —— Spring（循环依赖问题）
循环依赖

 简朴来说，就是多个bean之间相互依赖，终极形成闭环，极限情况，以致可能出现本身依赖本身
  1. @Component
  2. public class A {
  3.     // A中注入了B
  4.         @Autowired
  5.         private B b;
  6. }
  8. @Component
  9. public class B {
  10.     // B中也注入了A
  11.         @Autowired
  12.         private A a;
  13. }
复制代码

循环依赖发生的场景

当Bean通过构造器注入相互依赖时，Spring无法解决这种循环依赖，因为在构造器调用之前，Bean尚未创建，无法注入。
  1. @Component
  2. public class Person {
  3.     public Person(User user) {}
  4. }
  6. @Component
  7. public class User {
  8.     public User(Person person){}
  9. }
复制代码
项目中如果出现此类代码，会抛出非常BeanCurrentlyInCreationException
  1. 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?
  2.         at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:339)
  3.         at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:215)
  4.         at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318)
  5.         at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199)
复制代码
通过字段（field）或setter方法注入依赖时，Spring可以通过三级缓存来解决循环依赖问题。
  1. @Component
  2. public class User {
  3.     @Autowired
  4.     Person person;
  5. }
  6. @Component
  7. public class Person {
  8.     @Autowired
  9.     User user;
  10. }
复制代码
项目可以正常运行
对于多例（prototype）作用域的Bean，Spring默认不会在启动时初始化，而是在使用时才初始化，因此可能不会立即出现循环依赖问题，但在现实使用中可能会遇到。
  1. @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
  2. @Component
  3. public class User {
  4.     @Autowired
  5.     Person person;
  6. }
  7. @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
  8. @Component
  9. public class Person {
  10.     @Autowired
  11.     User user;
  12. }
复制代码
项目启动时，不会立即抛非常，因为多例的只有在被调用时，才会进行初始化，当被调用时就会抛非常
  1. org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'mytest.TestSpringBean': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'a': Unsatisfied dependency expressed through field 'b'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'b': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?
  2.         at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:596)
  3.         at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:90)
  4.         at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:374)
复制代码
Spring容器的三级缓存

解决循环依赖的步调

 Spring在实例化Bean时，会先创建一个空的Bean对象，并将其放入三级缓存中，Spring开始对Bean进行属性赋值，如果发现循环依赖，会通过工厂方法提前暴露一个原始的Bean实例，并将其放入二级缓存，这样，当其他Bean引用该Bean时，可以使用这个原始实例，避免了循环依赖
简朴的循环依赖（没有AOP）


结合了AOP的循环依赖


对A进行了AOP代理的话，此时getEarlyBeanReference将返回一个代理后的对象，而不是实例化阶段创建的对象

 三级缓存为什么要使用工厂而不是直接使用引用？换而言之，为什么需要这个三级缓存，直接通过二级缓存暴露一个引用不行吗？
答：这个工厂的目的在于耽误对实例化阶段天生的对象的代理，只有真正发生循环依赖的时间，才去提前天生代理对象，否则只会创建一个工厂并将其放入到三级缓存中，但是不会去通过这个工厂去真正创建对象

总结


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代理。




参考文章：口试必杀技，讲一讲Spring中的循环依赖

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4