上一篇博客，讲了下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条件里？这些问题先记着，等分析依赖注入时候再回过头来解决。
总结
到了这里，还是有很多不知道有什么用的缓存。这些缓存会在研究依赖注入以及循环引用时候继续分析。
