女朋友都能看懂，Spring如何解决循环依赖？

 

创新互联成立以来不断整合自身及行业资源、不断突破观念以使企业策略得到完善和成熟，建立了一套“以技术为基点，以客户需求中心、市场为导向”的快速反应体系。对公司的主营项目，如中高端企业网站企划 / 设计、行业 / 企业门户设计推广、行业门户平台运营、成都APP应用开发、手机网站制作、微信网站制作、软件开发、多线BGP机房等实行标准化操作，让客户可以直观的预知到从创新互联可以获得的服务效果。

本文转载自微信公众号「 Java识堂」，作者李立敏。转载本文请联系 Java识堂公众号。

介绍

先说一下什么是循环依赖，Spring在初始化A的时候需要注入B，而初始化B的时候需要注入A，在Spring启动后这2个Bean都要被初始化完成

Spring的循环依赖有两种场景

  1. 构造器的循环依赖
  2. 属性的循环依赖

构造器的循环依赖，可以在构造函数中使用@Lazy注解延迟加载。在注入依赖时，先注入代理对象，当首次使用时再创建对象完成注入

属性的循环依赖主要是通过3个map来解决的

构造器的循环依赖

 
 
 
    
  
  
  
  1. @Component 
    2. 
  
  
  
  2. public class ConstructorA { 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.  private ConstructorB constructorB; 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.  @Autowired 
    7. 
  
  
  
  7.  public ConstructorA(ConstructorB constructorB) { 
    8. 
  
  
  
  8.   this.constructorB = constructorB; 
    9. 
  
  
  
  9.  } 
    10. 
  
  
  
  10. } 
    11. 
  
  
  
  11. @Component 
    12. 
  
  
  
  12. public class ConstructorB { 
    13. 
  
  
  
  13.  
    14. 
  
  
  
  14.  private ConstructorA constructorA; 
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16.  @Autowired 
    17. 
  
  
  
  17.  public ConstructorB(ConstructorA constructorA) { 
    18. 
  
  
  
  18.   this.constructorA = constructorA; 
    19. 
  
  
  
  19.  } 
    20. 
  
  
  
  20. } 
    21. 
  
  
  
  21. @Configuration 
    22. 
  
  
  
  22. @ComponentScan("com.javashitang.dependency.constructor") 
    23. 
  
  
  
  23. public class ConstructorConfig { 
    24. 
  
  
  
  24. } 
    25. 
  
  
  
  25. public class ConstructorMain { 
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27.  public static void main(String[] args) { 
    28. 
  
  
  
  28.   AnnotationConfigApplicationContext context = 
    29. 
  
  
  
  29.     new AnnotationConfigApplicationContext(ConstructorConfig.class); 
    30. 
  
  
  
  30.   System.out.println(context.getBean(ConstructorA.class)); 
    31. 
  
  
  
  31.   System.out.println(context.getBean(ConstructorB.class)); 
    32. 
  
  
  
  32.  } 
    33. 
  
  
  
  33. } 
    34.

运行ConstructorMain的main方法的时候会在第一行就报异常，说明Spring没办法初始化所有的Bean，即上面这种形式的循环依赖Spring无法解决。

我们可以在ConstructorA或者ConstructorB构造函数的参数上加上@Lazy注解就可以解决

 
 
 
    
  
  
  
  1. @Autowired 
    2. 
  
  
  
  2. public ConstructorB(@Lazy ConstructorA constructorA) { 
    3. 
  
  
  
  3.  this.constructorA = constructorA; 
    4. 
  
  
  
  4. } 
    5.

因为我们主要关注属性的循环依赖，构造器的循环依赖就不做过多分析了

属性的循环依赖

先演示一下什么是属性的循环依赖

 
 
 
    
  
  
  
  1. @Component 
    2. 
  
  
  
  2. public class FieldA { 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.  @Autowired 
    5. 
  
  
  
  5.  private FieldB fieldB; 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. @Component 
    8. 
  
  
  
  8. public class FieldB { 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.  @Autowired 
    11. 
  
  
  
  11.  private FieldA fieldA; 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13. @Configuration 
    14. 
  
  
  
  14. @ComponentScan("com.javashitang.dependency.field") 
    15. 
  
  
  
  15. public class FieldConfig { 
    16. 
  
  
  
  16. } 
    17. 
  
  
  
  17. public class FieldMain { 
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.  public static void main(String[] args) { 
    20. 
  
  
  
  20.   AnnotationConfigApplicationContext context = 
    21. 
  
  
  
  21.     new AnnotationConfigApplicationContext(FieldConfig.class); 
    22. 
  
  
  
  22.   // com.javashitang.dependency.field.FieldA@3aa9e816 
    23. 
  
  
  
  23.   System.out.println(context.getBean(FieldA.class)); 
    24. 
  
  
  
  24.   // com.javashitang.dependency.field.FieldB@17d99928 
    25. 
  
  
  
  25.   System.out.println(context.getBean(FieldB.class)); 
    26. 
  
  
  
  26.  } 
    27. 
  
  
  
  27. } 
    28.

Spring容器正常启动，能获取到FieldA和FieldB这2个Bean

属性的循环依赖在面试中还是经常被问到的。总体来说也不复杂，但是涉及到Spring Bean的初始化过程，所以感觉比较复杂，我写个demo演示一下整个过程

Spring的Bean的初始化过程其实比较复杂，为了方便理解Demo，我就把Spring Bean的初始化过程分为2部分

  1. bean的实例化过程，即调用构造函数将对象创建出来
  2. bean的初始化过程，即填充bean的各种属性

bean初始化过程完毕，则bean就能被正常创建出来了

下面开始写Demo，ObjectFactory接口用来生产Bean，和Spring中定义的接口一样

 
 
 
    
  
  
  
  1. public interface ObjectFactory { 
    2. 
  
  
  
  2.  T getObject(); 
    3. 
  
  
  
  3. } 
    4. 
  
  
  
  4. public class DependencyDemo { 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.  // 初始化完毕的Bean 
    7. 
  
  
  
  7.  private final Map singletonObjects = 
    8. 
  
  
  
  8.    new ConcurrentHashMap<>(256); 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.  // 正在初始化的Bean对应的工厂，此时对象已经被实例化 
    11. 
  
  
  
  11.  private final Map> singletonFactories = 
    12. 
  
  
  
  12.    new HashMap<>(16); 
    13. 
  
  
  
  13.  
    14. 
  
  
  
  14.  // 存放正在初始化的Bean，对象还没有被实例化之前就放进来了 
    15. 
  
  
  
  15.  private final Set singletonsCurrentlyInCreation = 
    16. 
  
  
  
  16.    Collections.newSetFromMap(new ConcurrentHashMap<>(16)); 
    17. 
  
  
  
  17.  
    18. 
  
  
  
  18.  public   T getBean(Class beanClass) throws Exception { 
    19. 
  
  
  
  19.   // 类名为Bean的名字 
    20. 
  
  
  
  20.   String beanName = beanClass.getSimpleName(); 
    21. 
  
  
  
  21.   // 已经初始化好了，或者正在初始化 
    22. 
  
  
  
  22.   Object initObj = getSingleton(beanName, true); 
    23. 
  
  
  
  23.   if (initObj != null) { 
    24. 
  
  
  
  24.    return (T) initObj; 
    25. 
  
  
  
  25.   } 
    26. 
  
  
  
  26.   // bean正在被初始化 
    27. 
  
  
  
  27.   singletonsCurrentlyInCreation.add(beanName); 
    28. 
  
  
  
  28.   // 实例化bean 
    29. 
  
  
  
  29.   Object object = beanClass.getDeclaredConstructor().newInstance(); 
    30. 
  
  
  
  30.   singletonFactories.put(beanName, () -> { 
    31. 
  
  
  
  31.    return object; 
    32. 
  
  
  
  32.   }); 
    33. 
  
  
  
  33.   // 开始初始化bean，即填充属性 
    34. 
  
  
  
  34.   Field[] fields = object.getClass().getDeclaredFields(); 
    35. 
  
  
  
  35.   for (Field field : fields) { 
    36. 
  
  
  
  36.    field.setAccessible(true); 
    37. 
  
  
  
  37.    // 获取需要注入字段的class 
    38. 
  
  
  
  38.    Class fieldClass = field.getType(); 
    39. 
  
  
  
  39.    field.set(object, getBean(fieldClass)); 
    40. 
  
  
  
  40.   } 
    41. 
  
  
  
  41.   // 初始化完毕 
    42. 
  
  
  
  42.   singletonObjects.put(beanName, object); 
    43. 
  
  
  
  43.   singletonsCurrentlyInCreation.remove(beanName); 
    44. 
  
  
  
  44.   return (T) object; 
    45. 
  
  
  
  45.  } 
    46. 
  
  
  
  46.  
    47. 
  
  
  
  47.  /** 
    48. 
  
  
  
  48.   * allowEarlyReference参数的含义是Spring是否允许循环依赖，默认为true 
    49. 
  
  
  
  49.   * 所以当allowEarlyReference设置为false的时候，当项目存在循环依赖，会启动失败 
    50. 
  
  
  
  50.   */ 
    51. 
  
  
  
  51.  public Object getSingleton(String beanName, boolean allowEarlyReference) { 
    52. 
  
  
  
  52.   Object singletonObject = this.singletonObjects.get(beanName); 
    53. 
  
  
  
  53.   if (singletonObject == null  
    54. 
  
  
  
  54.     && isSingletonCurrentlyInCreation(beanName)) { 
    55. 
  
  
  
  55.    synchronized (this.singletonObjects) { 
    56. 
  
  
  
  56.     if (singletonObject == null && allowEarlyReference) { 
    57. 
  
  
  
  57.      ObjectFactory singletonFactory = 
    58. 
  
  
  
  58.        this.singletonFactories.get(beanName); 
    59. 
  
  
  
  59.      if (singletonFactory != null) { 
    60. 
  
  
  
  60.       singletonObject = singletonFactory.getObject(); 
    61. 
  
  
  
  61.      } 
    62. 
  
  
  
  62.     } 
    63. 
  
  
  
  63.    } 
    64. 
  
  
  
  64.   } 
    65. 
  
  
  
  65.   return singletonObject; 
    66. 
  
  
  
  66.  } 
    67. 
  
  
  
  67.  
    68. 
  
  
  
  68.  /** 
    69. 
  
  
  
  69.   * 判断bean是否正在被初始化 
    70. 
  
  
  
  70.   */ 
    71. 
  
  
  
  71.  public boolean isSingletonCurrentlyInCreation(String beanName) { 
    72. 
  
  
  
  72.   return this.singletonsCurrentlyInCreation.contains(beanName); 
    73. 
  
  
  
  73.  } 
    74. 
  
  
  
  74.  
    75. 
  
  
  
  75. } 
    76.

测试一波

 
 
 
    
  
  
  
  1. public static void main(String[] args) throws Exception { 
    2. 
  
  
  
  2.  DependencyDemo dependencyDemo = new DependencyDemo(); 
    3. 
  
  
  
  3.  // 假装扫描出来的对象 
    4. 
  
  
  
  4.  Class[] classes = {A.class, B.class}; 
    5. 
  
  
  
  5.  // 假装项目初始化所有bean 
    6. 
  
  
  
  6.  for (Class aClass : classes) { 
    7. 
  
  
  
  7.   dependencyDemo.getBean(aClass); 
    8. 
  
  
  
  8.  } 
    9. 
  
  
  
  9.  // true 
    10. 
  
  
  
  10.  System.out.println( 
    11. 
  
  
  
  11.    dependencyDemo.getBean(B.class).getA() == dependencyDemo.getBean(A.class)); 
    12. 
  
  
  
  12.  // true 
    13. 
  
  
  
  13.  System.out.println( 
    14. 
  
  
  
  14.    dependencyDemo.getBean(A.class).getB() == dependencyDemo.getBean(B.class)); 
    15. 
  
  
  
  15. } 
    16.

是不是很简单?我们只用了2个map就搞定了Spring的循环依赖

2个Map就能搞定循环依赖，那为什么Spring要用3个Map呢?

原因其实也很简单，当我们从singletonFactories中根据BeanName获取相应的ObjectFactory，然后调用getObject()这个方法返回对应的Bean。在我们的例子中 ObjectFactory的实现很简单哈，就是将实例化好的对象直接返回，但是在Spring中就没有这么简单了，执行过程比较复杂，为了避免每次拿到ObjectFactory然后调用getObject()，我们直接把ObjectFactory创建的对象缓存起来不就行了，这样就能提高效率了

比如A依赖B和C，B和C又依赖A，如果不做缓存那么初始化B和C都会调用A对应的ObjectFactory的getObject()方法。如果做缓存只需要B或者C调用一次即可。

知道了思路，我们把上面的代码改一波，加个缓存。

 
 
 
    
  
  
  
  1. public class DependencyDemo { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.  // 初始化完毕的Bean 
    4. 
  
  
  
  4.  private final Map singletonObjects = 
    5. 
  
  
  
  5.    new ConcurrentHashMap<>(256); 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.  // 正在初始化的Bean对应的工厂，此时对象已经被实例化 
    8. 
  
  
  
  8.  private final Map> singletonFactories = 
    9. 
  
  
  
  9.    new HashMap<>(16); 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.  // 缓存Bean对应的工厂生产好的Bean 
    12. 
  
  
  
  12.  private final Map earlySingletonObjects = 
    13. 
  
  
  
  13.    new HashMap<>(16); 
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15.  // 存放正在初始化的Bean，对象还没有被实例化之前就放进来了 
    16. 
  
  
  
  16.  private final Set singletonsCurrentlyInCreation = 
    17. 
  
  
  
  17.    Collections.newSetFromMap(new ConcurrentHashMap<>(16)); 
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.  public   T getBean(Class beanClass) throws Exception { 
    20. 
  
  
  
  20.   // 类名为Bean的名字 
    21. 
  
  
  
  21.   String beanName = beanClass.getSimpleName(); 
    22. 
  
  
  
  22.   // 已经初始化好了，或者正在初始化 
    23. 
  
  
  
  23.   Object initObj = getSingleton(beanName, true); 
    24. 
  
  
  
  24.   if (initObj != null) { 
    25. 
  
  
  
  25.    return (T) initObj; 
    26. 
  
  
  
  26.   } 
    27. 
  
  
  
  27.   // bean正在被初始化 
    28. 
  
  
  
  28.   singletonsCurrentlyInCreation.add(beanName); 
    29. 
  
  
  
  29.   // 实例化bean 
    30. 
  
  
  
  30.   Object object = beanClass.getDeclaredConstructor().newInstance(); 
    31. 
  
  
  
  31.   singletonFactories.put(beanName, () -> { 
    32. 
  
  
  
  32.    return object; 
    33. 
  
  
  
  33.   }); 
    34. 
  
  
  
  34.   // 开始初始化bean，即填充属性 
    35. 
  
  
  
  35.   Field[] fields = object.getClass().getDeclaredFields(); 
    36. 
  
  
  
  36.   for (Field field : fields) { 
    37. 
  
  
  
  37.    field.setAccessible(true); 
    38. 
  
  
  
  38.    // 获取需要注入字段的class 
    39. 
  
  
  
  39.    Class fieldClass = field.getType(); 
    40. 
  
  
  
  40.    field.set(object, getBean(fieldClass)); 
    41. 
  
  
  
  41.   } 
    42. 
  
  
  
  42.   singletonObjects.put(beanName, object); 
    43. 
  
  
  
  43.   singletonsCurrentlyInCreation.remove(beanName); 
    44. 
  
  
  
  44.   earlySingletonObjects.remove(beanName); 
    45. 
  
  
  
  45.   return (T) object; 
    46. 
  
  
  
  46.  } 
    47. 
  
  
  
  47.  
    48. 
  
  
  
  48.  /** 
    49. 
  
  
  
  49.   * allowEarlyReference参数的含义是Spring是否允许循环依赖，默认为true 
    50. 
  
  
  
  50.   */ 
    51. 
  
  
  
  51.  public Object getSingleton(String beanName, boolean allowEarlyReference) { 
    52. 
  
  
  
  52.   Object singletonObject = this.singletonObjects.get(beanName); 
    53. 
  
  
  
  53.   if (singletonObject == null 
    54. 
  
  
  
  54.     && isSingletonCurrentlyInCreation(beanName)) { 
    55. 
  
  
  
  55.    synchronized (this.singletonObjects) { 
    56. 
  
  
  
  56.     singletonObject = this.earlySingletonObjects.get(beanName); 
    57. 
  
  
  
  57.     if (singletonObject == null && allowEarlyReference) { 
    58. 
  
  
  
  58.      ObjectFactory singletonFactory = 
    59. 
  
  
  
  59.        this.singletonFactories.get(beanName); 
    60. 
  
  
  
  60.      if (singletonFactory != null) { 
    61. 
  
  
  
  61.       singletonObject = singletonFactory.getObject(); 
    62. 
  
  
  
  62.       this.earlySingletonObjects.put(beanName, singletonObject); 
    63. 
  
  
  
  63.       this.singletonFactories.remove(beanName); 
    64. 
  
  
  
  64.      } 
    65. 
  
  
  
  65.     } 
    66. 
  
  
  
  66.    } 
    67. 
  
  
  
  67.   } 
    68. 
  
  
  
  68.   return singletonObject; 
    69. 
  
  
  
  69.  } 
    70. 
  
  
  
  70. } 
    71.

我们写的getSingleton的实现和org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)的实现一模一样，这个方法几乎所有分析Spring循环依赖的文章都会提到，这次你明白工作原理是什么了把

总结一波

拿bean的时候先从singletonObjects(一级缓存)中获取

如果获取不到，并且对象正在创建中，就从earlySingletonObjects(二级缓存)中获取

如果还是获取不到就从singletonFactories(三级缓存)中获取，然后将获取到的对象放到earlySingletonObjects(二级缓存)中，并且将bean对应的singletonFactories(三级缓存)清除

bean初始化完毕，放到singletonObjects(一级缓存)中，将bean对应的earlySingletonObjects(二级缓存)清除

新闻名称：女朋友都能看懂，Spring如何解决循环依赖？
分享URL：http://www.csdahua.cn/qtweb/news36/494786.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

企业网站制作知识

行业网站建设

圣与卓设计　　 　恒翔机电　　 　犀浦防纹窗　　 　南充网站建设　　 　名片　　 　成都服务器租用　　 　鸿艺文化　　 　成都网站设计公司　　 　广元双南建站　　 　东电技服　　 　广安搬家公司　　 　注册域名　　 　网站优化公司　　 　网站SEO优化　　 　注册域名　　 　IOS开发　　 　企业营销型网站　　 　成都楼顶广告牌　　 　成都免费自助建站　　 　西信服务器托管