【spring源码分析】IOC容器初始化(十二)

前言:在doCreateBean方法中还遗留一个问题没有分析:循环依赖。循环依赖在Spring中是非常重要的一个知识点,因此单独进行分析。


什么是循环依赖

循环依赖就是循环引用,两个或两个以上的bean互相引用对方,最终形成一个闭环。如A依赖B,B依赖C,C依赖A。如下图所示:

循环依赖其实就是一个死循环的过程,在初始化A的时候发现引用了B,则就会去初始化B,然后发现B又引用C,则又去初始化C,在初始化C的时候,再次发现C引用了A,则又去初始化A,这样就处于死循环,除非有终结条件。

Spring中循环依赖的场景有两种:

  • 构造器循环依赖。
  • setter循环依赖。

构造器循环依赖

表示通过构造器注入构成的循环依赖,此依赖是无法解决的,只能抛出BeanCurrentlyInCreationException异常。

setter循环依赖

表示通过setter注入方式构成的循环依赖,对于setter注入造成的循环依赖,Spring只解决单例模式下的循环依赖,对于其他作用域的循环依赖,则抛出BeanCurrentlyInCreationException异常。为什么Spring只解决单例模式下的循环依赖呢,这里首先了解下Spring的几个作用域。

Spring的scope作用域

  • singleton:默认的scope,每个scope是singleton的bean都会被定义一个单例对象,该对象的生命周期与Spring IOC容器一致的(但在第一次注入时才会创建)。
  • prototype:如果为bean的作用域为prototype,则每次注入时都会创建一个新的对象。
  • request:bean被定义为在每个HTTP请求 中创建一个单例对象,也就是说在单个请求中都会复用这个单例对象。
  • session:bean被定义为在一个session的生命周期内创建一个单例对象。
  • application:bean被定义为在ServletContext的生命周期中复用一个单例对象。
  • websocket:bean被定义为在websocket的生命周期中复用一个单例对象。

从上面对Spring中scope作用域的介绍,也可大致了解为什么Spring中只解决单例模式下的循环依赖了,因为其他作用域对象的生命周期并不与Spring IOC容器一致,并且最主要的一点是Spring并不会对除了单例模式的bean做缓存,因此Spring只能解决单例模式下的循环依赖。

具体循环依赖解决流程

首先在看bean的加载的入口,在doGetBean方法中有如下代码:

首先会根据beanName从单例bean缓存中获取,如果不为空,则直接返回,前面已经分析了该方法,这里再次提出来。

 1 // DefaultListableBeanFactory
 2 protected Object getSingleton(String beanName, boolean allowEarlyReference) {
 3         // 从单例缓存中加载Bean
 4         Object singletonObject = this.singletonObjects.get(beanName);
 5         // 缓存中bean为空,且当前bean正在创建
 6         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
 7             // 做同步
 8             synchronized (this.singletonObjects) {
 9                 // 从earlySingletonObjects集合中获取
10                 singletonObject = this.earlySingletonObjects.get(beanName);
11                 // earlySingletonObjects集合中没有,其允许提前创建
12                 if (singletonObject == null && allowEarlyReference) {
13                     // 从singletonFactories中获取对应的ObjectFactory
14                     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
15                     if (singletonFactory != null) {
16                         // 获取bean
17                         singletonObject = singletonFactory.getObject();
18                         // 将bean添加到earlySingletonObjects集合中
19                         this.earlySingletonObjects.put(beanName, singletonObject);
20                         // 从singletonFactories中移除对应的
21                         this.singletonFactories.remove(beanName);
22                     }
23                 }
24             }
25         }
26         return singletonObject;
27     }

分析:

这里注意isSingletonCurrentlyInCreation函数,判断当前bean是否正在被创建,这里就是判断beanName是否在singletonsCurrentlyInCreation集合中,那么正在被创建的bean是合适添加进去的呢?还是在doGetBean方法中

 1 // DefaultSingletonBeanRegistry
 2 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
 3         Assert.notNull(beanName, "Bean name must not be null");
 4         // 做同步
 5         synchronized (this.singletonObjects) {
 6             // 从缓存中检查一遍
 7             // 因为singlton模式其实已经复用了创建的bean,所以该步骤必须检查
 8             Object singletonObject = this.singletonObjects.get(beanName);
 9             // 为空,开始进行加载
10             if (singletonObject == null) {
11                 if (this.singletonsCurrentlyInDestruction) {
12                     throw new BeanCreationNotAllowedException(beanName,
13                                                               "Singleton bean creation not allowed while singletons of this factory are in destruction " +
14                                                                       "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
15                 }
16                 if (logger.isDebugEnabled()) {
17                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
18                 }
19                 // 加载前置处理 其实就是打一个标记
20                 beforeSingletonCreation(beanName);
21                 // 首先将新的newSingleton设置为false
22                 boolean newSingleton = false;
23                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
24                 if (recordSuppressedExceptions) {
25                     this.suppressedExceptions = new LinkedHashSet<>();
26                 }
27                 try {
28                     // 初始化bean
29                     // 该过程其实是调用createBean()方法 这里是一个回调方法
30                     singletonObject = singletonFactory.getObject();
31                     newSingleton = true;
32                 } catch (IllegalStateException ex) {
33                     // Has the singleton object implicitly appeared in the meantime ->
34                     // if yes, proceed with it since the exception indicates that state.
35                     singletonObject = this.singletonObjects.get(beanName);
36                     if (singletonObject == null) {
37                         throw ex;
38                     }
39                 } catch (BeanCreationException ex) {
40                     if (recordSuppressedExceptions) {
41                         for (Exception suppressedException : this.suppressedExceptions) {
42                             ex.addRelatedCause(suppressedException);
43                         }
44                     }
45                     throw ex;
46                 } finally {
47                     if (recordSuppressedExceptions) {
48                         this.suppressedExceptions = null;
49                     }
50                     // 一堆异常处理后,进行后置处理 移除标志
51                     afterSingletonCreation(beanName);
52                 }
53                 // 新的bean 加入缓存中
54                 if (newSingleton) {
55                     addSingleton(beanName, singletonObject);
56                 }
57             }
58             return singletonObject;
59         }

分析:

注意第20行代码beforeSingletonCreation函数。

1 // DefaultSingletonBeanRegistry
2 protected void beforeSingletonCreation(String beanName) {
3         // 这里会添加到正在创建bean的集合中
4         // 注意第一个条件,如果存在,则为false,直接短路
5         // 只有当第一个条件不存在[false]时,才会去进行添加操作
6         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
7             throw new BeanCurrentlyInCreationException(beanName);
8         }
9     }

分析:

这里就会将正在创建的beanName添加到singletonsCurrentlyInCreation,如果出现构造函数的循环依赖bean注入,则会在此处抛出BeanCurrentlyCreationException异常,具体可以跟着代码调试一把,就可以更清楚的知晓流程。

接下来继续回到单例模式的循环依赖中:

在加载bean时,首先从单例缓存中获取bean对象。

  • 首先从单例缓存中获取bean对象,如果缓存中存在bean对象则直接返回(单例模式的bean在创建过程中会进行缓存[singletonObjects])。
  • 如果缓存中bean对象为空,且当前bean正在创建,则从earlySingletonObjects中获取。
  • 如果earlySingletonObjects集合中不存在,且允许提前创建bean,则从singletonFactories中获取单例工厂,若singleFactory不为空,则通过getObject方法获取bean,并将bean对象加入到earlySingletonObjects集合中,然后从singleFactory集合中移除对应的单例工厂对象。

注意这里涉及到三个集合:

  • singletonObjects (一级)单例对象 Cache
  • earlySingletonObjects (二级)提前曝光的单例对象 Cache
  • singletonFactories (三级)单例对象工厂 Cache
 1 /**
 2      * Cache of singleton objects: bean name to bean instance.
 3      * 存放的是单例 bean 的映射。
 4      * <p>
 5      * 对应关系为 bean name --> bean instance
 6      */
 7     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
 8 
 9     /**
10      * Cache of singleton factories: bean name to ObjectFactory.<br/>
11      * 存放的是 ObjectFactory,可以理解为创建单例 bean 的 factory 。
12      * <p>
13      * 对应关系是 bean name --> ObjectFactory
14      */
15     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
16 
17     /**
18      * Cache of early singleton objects: bean name to bean instance.<br/>
19      * 存放的是早期的 bean,对应关系也是 bean name --> bean instance。
20      * <p>
21      * 它与 {@link #singletonFactories} 区别在于 earlySingletonObjects 中存放的 bean 不一定是完整。
22      * <p>
23      * 从 {@link #getSingleton(String)} 方法中,我们可以了解,bean 在创建过程中就已经加入到 earlySingletonObjects 中了。
24      * 所以当在 bean 的创建过程中,就可以通过 getBean() 方法获取。
25      * <p>
26      * 这个 Map 也是【循环依赖】的关键所在。
27      */
28     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

这三个缓存集合就是解决Spring中循环依赖的所在,具体流程:

  • 首先从一级缓存singletonObjects中获取,如果为null,且当前bean正在被创建,则从二级缓存earlySingletonObjects中获取,如果还是为null,且允许singletonFactories通过getObject获取,则从三级缓存singletonFactories中获取,如果得到,则将其加入二级缓存earlySingletonObjects中,并从三级缓存singletonFactories中移除对应的工厂对象(因为单例模式的bean只会被创建一次),这样三级缓存就升级到二级缓存了,所以二级缓存存在的意义就是缓存三级缓存中ObjectFactory#getObject的执行结果,提前曝光单例Bean对象。

如果从单例缓存中得到bean对象,则会调用getObjectForBeanInstance方法进一步处理,因为从缓存中得到的bean是最原始的bean,并不一定是最终所需要的bean对象。

上面分析了从缓存中获取bean对象,但是缓存中的值是从什么地方添加进来的呢?如果你调试过源码会发现这样一段代码:

 1 // AbstractAutowireCapableBeanFactory
 2     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
 3                 isSingletonCurrentlyInCreation(beanName));// 当前单例bean是否正在被创建
 4         if (earlySingletonExposure) {
 5             if (logger.isDebugEnabled()) {
 6                 logger.debug("Eagerly caching bean '" + beanName +
 7                                      "' to allow for resolving potential circular references");
 8             }
 9             // 提前将创建的bean实例加入到singletonFactories中
10             // 为了后期避免循环依赖
11             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
12         }

分析:

当一个bean满足三个条件,则会被加入到缓存中。三个条件如下:

  • 单例。
  • 运行提前暴露bean。
  • 当前bean正在被创建中。

DefaultSingletonBeanRegistry#addSingletonFactroy

 1     protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
 2         Assert.notNull(singletonFactory, "Singleton factory must not be null");
 3         synchronized (this.singletonObjects) {
 4             if (!this.singletonObjects.containsKey(beanName)) {
 5                 this.singletonFactories.put(beanName, singletonFactory);
 6                 this.earlySingletonObjects.remove(beanName);
 7                 this.registeredSingletons.add(beanName);
 8             }
 9         }
10     }

分析:

  • 如果单例缓存中不存在beanName,则将singletonFactory进行缓存[singletonFactories集合],注意这里还有一个earlySingletonObjects.remove操作,该操作是删除二级缓存(提前曝光的单例对象bean),因为二级缓存是从三级缓存转换而来的,因此在对三级缓存[singletonFactories]进行缓存时,需要remove二级缓存。
  • 这段代码发生在createBeanInstance方法之后,也就是说这个bean其实已经被创建出来了,但它还是不是很完美(没有进行属性填充和初始化),但是对于其他依赖它的对象而言已经足够了(可根据对象引用定位到堆中对象),能够被认出来。所以Spring解决setter构造依赖的关键,就是对bean进行提前曝光。

上面介绍的了三级缓存[singletonFactories]与二级缓存[earlySingletonObjects]的出处,接下来看一级缓存的出处:

在DefaultSingletonBeanRegistry#getSingleton函数中:

 1 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
 2         Assert.notNull(beanName, "Bean name must not be null");
 3         // 做同步
 4         synchronized (this.singletonObjects) {
 5             // 从缓存中检查一遍
 6             // 因为singlton模式其实已经复用了创建的bean,所以该步骤必须检查
 7             Object singletonObject = this.singletonObjects.get(beanName);
 8             // 为空,开始进行加载
 9             if (singletonObject == null) {
10                 if (this.singletonsCurrentlyInDestruction) {
11                     throw new BeanCreationNotAllowedException(beanName,
12                                                               "Singleton bean creation not allowed while singletons of this factory are in destruction " +
13                                                                       "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
14                 }
15                 if (logger.isDebugEnabled()) {
16                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
17                 }
18                 // 加载前置处理 其实就是打一个标记
19                 beforeSingletonCreation(beanName);
20                 // 首先将新的newSingleton设置为false
21                 boolean newSingleton = false;
22                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
23                 if (recordSuppressedExceptions) {
24                     this.suppressedExceptions = new LinkedHashSet<>();
25                 }
26                 try {
27                     // 初始化bean
28                     // 该过程其实是调用createBean()方法 这里是一个回调方法
29                     singletonObject = singletonFactory.getObject();
30                     newSingleton = true;
31                 } catch (IllegalStateException ex) {
32                     // Has the singleton object implicitly appeared in the meantime ->
33                     // if yes, proceed with it since the exception indicates that state.
34                     singletonObject = this.singletonObjects.get(beanName);
35                     if (singletonObject == null) {
36                         throw ex;
37                     }
38                 } catch (BeanCreationException ex) {
39                     if (recordSuppressedExceptions) {
40                         for (Exception suppressedException : this.suppressedExceptions) {
41                             ex.addRelatedCause(suppressedException);
42                         }
43                     }
44                     throw ex;
45                 } finally {
46                     if (recordSuppressedExceptions) {
47                         this.suppressedExceptions = null;
48                     }
49                     // 一堆异常处理后,进行后置处理 移除标志
50                     afterSingletonCreation(beanName);
51                 }
52                 // 新的bean 加入缓存中
53                 if (newSingleton) {
54                     addSingleton(beanName, singletonObject);
55                 }
56             }
57             return singletonObject;
58         }
59     }

分析:

这里关注第54行处:addSingleton函数。

1 // DefaultSingletonBeanRegistry
2     protected void addSingleton(String beanName, Object singletonObject) {
3         synchronized (this.singletonObjects) {
4             this.singletonObjects.put(beanName, singletonObject);
5             this.singletonFactories.remove(beanName);
6             this.earlySingletonObjects.remove(beanName);
7             this.registeredSingletons.add(beanName);
8         }
9     }

分析:

这里就是将bean加入一级缓存中[singletonObjects],同时remove二级缓存和三级缓存中值,因为bean已经被创建成功了,二级缓存与三级缓存也就不需要了。

总结

从上面分析过程可以知道为什么Spring只解决单例模式下的循环依赖了吧?

  • Spring只对单例模式的bean进行了提前暴光[singletonFactories],这也是由于其他scope域bean的特性所致。

单例模式下循环依赖解决流程:

  • 首先A完成初始化第一步并将自己提前曝光出来(通过 ObjectFactory 将自己提前曝光),A在初始化的时候,发现自己依赖对象 B,此时就会去尝试 get(B),这个时候发现 B 还没有被创建出来。
  • 然后B就走创建流程,在B初始化的时候,同样发现自己依赖 C,C也没有被创建出来。
  • 这个时候C又开始初始化进程,但是在初始化的过程中发现自己依赖 A,于是尝试 get(A),这个时候由于A已经添加至缓存中(一般都是添加至三级缓存singletonFactories),通过 ObjectFactory 提前曝光,所以可以通过ObjectFactory#getObject()方法来拿到 A 对象,C 拿到 A 对象后顺利完成初始化,然后将自己添加到一级缓存中
  • 回到B,B 也可以拿到 C 对象,完成初始化,A可以顺利拿到B完成初始化。到这里整个链路就已经完成了初始化过程了。

如果你看过《Spring源码深度解析》这本书,还能发现如下流程图:

注:看图说话,笔者最为喜欢!其实去亲身调试一下循环依赖的代码,可能会有更加深刻的认识。


by Shawn Chen,2019.04.29,下午。

posted @ 2019-04-29 15:05  developer_chan  阅读(499)  评论(0编辑  收藏  举报