Spring加载流程&Bean的生命周期

推荐篇博文 Spring中bean的生命周期（最详细）

循环依赖

解决循环依赖的关键是将【实例化】与【初始化】两个过程分开。

二级缓存

假设只使用二级缓存，能否解决循环依赖问题？答案是可以。
但是这仅限于在未使用AOP生成代理对象的情况下。

代理对象实例化的时候，实例化对象是原始对象
若没有三级缓存，此时若根据类名直接获取对象的话，获取的是原始对象
而我们想要的肯定是通过类名直接获取代理对象
所以Spring在类加载过程中，直接将实例化的对象放入三级缓存中
从三级缓存中获取类对象的时候，判断类是否被代理，若被代理则返回代理对象

三级缓存

Spring在启动过程中，使用到了三个map，称为三级缓存。

引用自https://blog.csdn.net/wuwu12dfda/article/details/105155065

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * Cache of singleton objects: bean name to bean instance.
 * 【一级缓存】用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用。
 */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/**
 * Cache of singleton factories: bean name to ObjectFactory.
 * 【三级缓存】用于存放 bean 工厂对象ObjectFactory（三级缓存中Bean的代理对象）
 * ObjectFactory.getObject()方法描述了如何获取这个三级缓存的对象。
 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** 
 * Cache of early singleton objects: bean name to bean instance. 
 * 【二级缓存】用于存放提前暴露的单例对象的cache，原始的 bean 对象（尚未填充属性，半成品bean）。
 */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

/** 
 * Names of beans that are currently in creation.
 * 正在创建中的beanName
 */
private final Set<String> singletonsCurrentlyInCreation =
    Collections.newSetFromMap(new ConcurrentHashMap<>(16));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//缓存查找bean，双重检查提高并发效率
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  //从一级缓存获取bean
  Object singletonObject = this.singletonObjects.get(beanName);
  //一级缓存中不存在，而且是在创建中
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    //从二级缓存中获取bean
    singletonObject = this.earlySingletonObjects.get(beanName);
    //二级缓存中不存在，而且允许循环依赖
    if (singletonObject == null && allowEarlyReference) {

      synchronized (this.singletonObjects) {
        //从一级缓存获取bean
        singletonObject = this.singletonObjects.get(beanName);
        //一级缓存中不存在
        if (singletonObject == null) {
          //从二级缓存中获取bean
          singletonObject = this.earlySingletonObjects.get(beanName);
          if (singletonObject == null) {
            //从三级缓存中获取返回扩展对象的工厂方法
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
              //获取扩展对象
              singletonObject = singletonFactory.getObject();
              //放入二级缓存
              this.earlySingletonObjects.put(beanName, singletonObject);
              //从三级缓存中移除
              this.singletonFactories.remove(beanName);
            }
          }
        }
      }

    }
  }
  return singletonObject;
}