论 spring 的三级缓存

论 spring 的三级缓存

预备知识

bean的生命周期

bean 的生命周期

为何会出现循环引用

这个问题只是出现在spring 容器的机制中其实我们代码中很简单就解决了。

假设A 对象里需要注入一个B属性B 对象里面需要注入一个A 属性。根据Bean 的生命周期先实例化A 的实例然后进行A属性的填充这时就需要一个B的对象在通过 beanFactory.getBean(B) 进行B对象的获取同样先进行B的实例化之后进行B中A属性的复制也会去调用beanFactory.getBean(A)进行获取但是A变量还没有创建完成singletonObjects变量池中没有所以就行程了循环引用为了解决这个问题就是A实例化之后想找一个变量进行存储后面有变量的创建需要用到她的话直接使用这个变量的对象earlySingletonObjects 这样就解决了循环依赖的问题。

伪代码如下

//伪代码就是这个意思 
static class A {
        private B b;

        public void setB(B b) {
            this.b = b;
        }
    }
    static class B {
        private A a;

        public void setA(A a) {
            this.a = a;
        }
    }

    public static void main(String[] args) {
        A earlySingletonObjects = new A();
        B b;
        {
            b = new B();
            b.setA(earlySingletonObjects);
        }
        earlySingletonObjects.setB(b);
        A a = earlySingletonObjects;
        // TODO:  use a use b 
    }

不用三级缓存行不行

首先提出一个观点不用三级缓存使用两级缓存行不行答案是肯定的没问题spring 为什么要使用三个变量池呢我想是这样分类更明确。

说道分类明确大家不禁有疑问为什么这么说呢是因为 假设 A 和B 之间进行循环引用并且我们对A 进行了切面增强逻辑如果我们只是将A的实例对象提前暴露出去是错误的因为B中我们真正想使用的是A增强后的对象。好了问题说清楚了那用两个变量行不行当然行了创建A 的时候我们在进行属性赋值的时候直接创建一个包含A 的代理对象并将代理对象放入earlySingletonObjects 提前暴露变量池中不就ok了吗等到B使用的时候直接拿到A的代理对象没有任何问题。所以我个人认为spring 在弄出一个singletonFactories 单纯就是解耦。

三级缓存不 是三个变量

分别存储在 这三个变量当中.

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

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

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

三个对象的赋值过程

过程详解

代码如下:

1. org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {	
    if (earlySingletonExposure) {
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
}

2. org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		Object sharedInstance = getSingleton(beanName);
}
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;
	}

3. org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        singletonObject = singletonFactory.getObject();
        newSingleton = true;
        if (newSingleton) {
            //该方法
            addSingleton(beanName, singletonObject);
        }
        return singletonObject;
     }
}

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

扩展出aop 代理对象如何创建

首先我们开启aspectj的注解会给容器注册一个 BeanPostProcessor class name 为 AnnotationAwareAspectJAutoProxyCreator

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
}

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}

AnnotationAwareAspectJAutoProxyCreator 的继承结构如下:

那么在什么时机去创建代理呢 有两个时机第一个是允许提前暴露的话在实例化好目标对象之后提前暴露给singletonFactories 当中时使用getEarlyBeanReference 方法进行动态代理的替换

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
    	BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
		
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
            //使用getEarlyBeanReference 方法进行动态代理的替换
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		return exposedObject;
	}

getEarlyBeanReference 所做的内容会调用所有的SmartInstantiationAwareBeanPostProcessor 的getEarlyBeanReference 方法

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
				}
			}
		}
		return exposedObject;
	}

此时创建代理对象

public Object getEarlyBeanReference(Object bean, String beanName) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		this.earlyProxyReferences.put(cacheKey, bean);
		return wrapIfNecessary(bean, beanName, cacheKey);
	}

剩下得流程该对目标对象属性赋值就赋值该初始化初始化。一切照旧只不过我们提前暴露的是 代理对象.

而after 做的是将为提前暴露的对象在代理一次

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

关于spring aop的源码分析可以参看:

<<spring技术内幕>>