初始化bean（二）—— 缓存部分

2021-12-12 06:34:09

上一篇博客，讲了下spring如何初始化bean的当然，当时只讨论了很简单的一种情况：初次加载bean时候，并且只考虑了单例。

这篇博客会试着理清楚spring在加载bean的时候的一部分缓存。关于解决循环引用所使用的缓存，可以看这篇博客

从doGetBean开始

首先再次回到doGetBean方法

上一篇博客里，我对doGetBean进行了简化，省略了很多多例及第二次加载相关的代码。

现在想下，如果让我们业务上使用缓存会怎么做。
1）先从缓存查下有没有所需数据
2）没有的话从db加载
3）加载后存到缓存里

缓存的用法无非是这样。spring也是这样使用的。

getSingleton方法

现在再来回顾getSingleton方法就很清楚了

这里我会把流程再简化下，去掉那些扩展的，异常处理等

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    synchronized (this.singletonObjects) {
        //先试着从缓存中加载
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            
            //异常检查 ... 
            //...
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            //异常记录...
            try {
                //调用ObjectFactory的getObject生成这个对象
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            // 省略了异常处理
            finally{
                  //....
                  afterSingletonCreation(beanName);
            }

            if (newSingleton) {
                //添加到缓存里
                addSingleton(beanName, singletonObject);
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

这样看就非常清楚了
1）从singleObjects试着找下对应的对象
2）从singletonFactory里创建对象
3）添加到缓存中

和我们平常使用缓存的方式没有任何不同

addSingleton记录缓存

看doGetBean方法，让我感到很晕的地方就是，各种各样缓存。（好多hashMap）而addSingleton方法就是操作缓存的一部分入口。

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

这里我们先挑看得懂的来分析。

Map<String, Object> singletonObjects 存放了 beanName -> 创建出来的对象
Set<String> registeredSingletons 存放了已注册的单例对象

好像就这两个看得懂哦(～￣▽￣)～没事我们继续分析下去

回到doGetBean开头

protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {

        final String beanName = transformedBeanName(name);
        Object bean;

        Object sharedInstance = getSingleton(beanName);
        //.....
}

doGetBean一开始就试图通过getSingleton方法获取对应的bean
我们再回头看下getSinglteton方法

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //已创建的对象里面找下
    Object singletonObject = this.singletonObjects.get(beanName);
    //没找到，并且当前类正在被创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

第一行很熟悉，从已加载的对象的缓存里找下。
第二行判断，从方法名很容易猜到意思。只有当从缓存里找不到，并且当前类正在被创建才会走到里面的逻辑。

看下isSingletonCurrentlyInCreation方法

public boolean isSingletonCurrentlyInCreation(String beanName) {
    return this.singletonsCurrentlyInCreation.contains(beanName);
}

这里又出现了一个不认识的缓存 = =

Set<String> singletonsCurrentlyInCreation

从变量名，很容易猜到是记录当前单例是否正在被创建。

我们跟下往这个set里添加值的地方。插入值的地方就在getSingleton里的beforeSingletonCreation 这一步里。
之前分析getSingleton方法时，我关注的是如何创建bean，如何使用singletonObjects缓存的。
其实在创建bean前，与创建bean后，有两个方法用于做些前置以及后置处理。分别是beforeSingletonCreation 与 afterSingletonCreation方法。

我们看下这两个方法里都做了啥

创建bean的前置与后置处理

protected void beforeSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

protected void afterSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

这里又出现了两个缓存 inCreationCheckExclusions 和 singletonsCurrentlyInCreation

inCreationCheckExclusions这个我们先不管，到了这里singletonsCurrentlyInCreation就很清楚了，spring会在创建一个单例对象之前，记录到singletonsCurrentlyInCreation里，在创建完后，从singletonsCurrentlyInCreation里删除。

Set<String> singletonsCurrentlyInCreation 当前正在创建的beanName

回到getSingleton方法

if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

到了这里我有几个问题：
1）为啥getSingleton方法里要进行这样的判断？
2）一般来说我们使用spring时候，都是单线程的。那么按照这个代码，创建之前添加进去，添加之后删除。那么岂不是永远不会走到这个if条件里？这些问题先记着，等分析依赖注入时候再回过头来解决。

总结

到了这里，还是有很多不知道有什么用的缓存。这些缓存会在研究依赖注入以及循环引用时候继续分析。

码农公寓