Spring三级缓存

作者: 知止9528 | 来源:发表于2019-02-03 15:25 被阅读0次

我们获取bean的步骤如下

->org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)
 ->org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
  ->org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)
   ->org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)

查看getSingleton()方法

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
                // 1
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                                // 2
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                                        // 3
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                                                // 4
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

说明
1处，在最上层的缓存singletonObjects中，获取单例bean，这里面拿到的bean，直接可以使用；如果没取到，则进入2处

2处，在2级缓存earlySingletonObjects中，查找bean；

3处，如果在2级缓存中，还是没找到，则在3级缓存中查找对应的工厂对象，利用拿到的工厂对象（工厂对象中，有3个field，一个是beanName，一个是RootBeanDefinition，一个是已经创建好的，但还没有注入属性的bean），去获取包装后的bean，或者说，代理后的bean。

什么是已经创建好的，但没有注入属性的bean？

比如一个bean，有10个字段，你new了之后，对象已经有了，内存空间已经开辟了，堆里已经分配了该对象的空间了，只是此时的10个field还是null。

对应的三个map


    /** Cache of singleton objects: bean name --> bean instance */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /** Cache of singleton factories: bean name --> ObjectFactory */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /** Cache of early singleton objects: bean name --> bean instance */
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

它们的作用是什么?

singletonObjects 用来放完全初始化的bean
earlySingletonObjects 用来放实例化了,但还未完全初始化的bean
singletonFactories 则用来放代理bean

问题

如果只用一个map会存在什么问题?

一级缓存的问题在于，就1个map，里面既有完整的已经ready的bean，也有不完整的，尚未设置field的bean。
如果这时候，有其他线程去这个map里获取bean来用怎么办？拿到的bean，不完整，怎么办呢？属性都是null，直接空指针了。

所以就有了放未完全初始化的bean的map

那为什么有需要三个map?

那是因为spring中还存在代理对象

而为什么使用一个工厂模式?

那是因为并不是所有对象都需要代理对象,使用工厂模式可以实现懒加载

我们再继续看怎么创建Bean的

->org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)
 ->org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
  ->org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)
   ->org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)
    ->org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(RootBeanDefinition, java.lang.Object[])
      ->org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

doCreateBean()代码如下

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        // 1 
        BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
        final Object bean = instanceWrapper.getWrappedInstance();
        
        if (earlySingletonExposure) {
            // 2
            addSingletonFactory(beanName, new ObjectFactory() {
                @Override
                public Object getObject() throws BeansException {
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }

        // 3 
        Object exposedObject = bean;
        // 4
        populateBean(beanName, mbd, instanceWrapper);
        
        // 5
        if (exposedObject != null) {
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }

        if (earlySingletonExposure) {
            // 6
            Object earlySingletonReference = getSingleton(beanName, false);
            
            if (earlySingletonReference != null) {
                // 7
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    // 8
                    ...
                }
            }
        }

        return exposedObject;
    }

说明
上面流程中，做了部分删减。但基本创建一个bean，就这几步了。
1处，创建bean对象，此时，属性什么的全是null，可以理解为，只是new了，field还没设置
2处，添加到第三级缓存；加进去的，只是个factory，只有循环依赖的时候，才会发挥作用
3处，把原始bean，存到exposedObject
4处，填充属性；循环依赖情况下，A/B循环依赖。假设当前为A，那么此时填充A的属性的时候，会去：new B；
填充B的field，发现field里有一个是A类型，然后就去getBean("A")，然后走到第三级缓存，拿到了A的ObjectFactory，然后调用ObjectFactory，然后调用AOP的后置处理器类：getEarlyBeanReference，拿到代理后的bean（假设此处切面满足，要创建代理）；
经过上面的步骤后，B里面，field已经填充ok，其中，且填充的field是代理后的A，这里命名为proxy A。
B 继续其他的后续处理。
B处理完成后，被填充到当前的origin A（原始A）的field中
5处，对A进行后置处理，此时调用aop后置处理器的，postProcessAfterInitialization；此时不会再去调用wrapIfNecessary(后面会再说明)，所以这里直接返回原始A，即 origin A
6处，去缓存里获取A，拿到的A，是proxy A
7处，我们梳理下：
exposedObject：origin A
bean：原始A
earlySingletonReference： proxy A
此时，下面这个条件是满足的，所以，exposedObject，最终被替换为proxy A：

if (exposedObject == bean) {
    exposedObject = earlySingletonReference;
}

最后我们再来着重说明下5处为什么返回的是原始A

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference

public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 1
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            this.earlyProxyReferences.add(cacheKey);
        }
        return wrapIfNecessary(bean, beanName, cacheKey);
    }

1处，往field：

private final Set<Object> earlyProxyReferences =
      Collections.newSetFromMap(new ConcurrentHashMap<Object, Boolean>(16));

里，加了个cachekey，这个cachekey，主要也就是如下的字符串，用来唯一标识而已。

protected Object getCacheKey(Class<?> beanClass, String beanName) {
        return beanClass.getName() + "_" + beanName;
    }

我们可以看看这个field在哪里被用到了。

image.png

也就两处，一处就是当前位置；另外一处，下面讲。

这里，主要就是看看到底要不要生成代理对象，要的话，就生成，不要就算了，另外，做了个标记：在earlyProxyReferences加了当前bean的key，表示：当前bean，已经被getEarlyBeanReference方法处理过了。

至于，最终到底有没有生成代理对象，另说。毕竟调用wrapIfNecessary也不是说，一定就满足切面，要生成代理对象。

可能返回的仍然是原始对象。

postProcessBeforeInitialization

public Object postProcessBeforeInitialization(Object bean, String beanName) {
   return bean;
}

这一处，没做处理。
postProcessAfterInitialization

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            // 1
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

这里,1处这个判断哈，就用到了前面我们说的那个field。那个field，只在两处用，一处就是调用getEarlyBeanReference，会往里面把当前bean的key放进去；另外一处，就是这里。

这里判断，如果field里不包含当前bean，就去调用wrapIfNecessary；如果包含（意味着，getEarlyBeanReference处理过了），就不调用了。

这里，说到底，就是保证了，wrapIfNecessary只被调用一次。

image.png

看吧，wrapIfNecessary也就这两处被调用了。

所以，我们可以得出结论，在aop这个beanPostProcessor中，有多处机会可以返回一个proxy对象，但是，最终，只要在其中一处处理了，其他处，根本不再继续处理。

另外，还有一点很重要，在这个aop beanPostProcessor中，传入了原始的bean，我们会去判断，是否要给它创建代理，如果要，就创建；如果不要则：

返回原始对象。

小结
Spring处理循环依赖,是使用了java对象,实例化->属性赋值->初始化的特性,在属性赋值之前提前暴露.所以也只能处理set注入
如果使用构造器则直接初始化了

Spring三级缓存

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读