一. 前言
Spring 的三级缓存、循环依赖,我们经常听到这两个词,包括面试也会被面试官问及三级缓存是啥?为啥需要三级缓存?循环依赖是啥?Spring 是如何解决循环依赖的?什么样的循环依赖 Spring 无法解决?
带着上述的问题,我们深入看一下 Spring BeanFactory 的 getBean() 流程;这篇文章需要看官有一定的 Spring 源码了解;
二. 三级缓存是指哪三个
三级缓存其实对应了三个 Map,它是在 DefaultSingletonBeanRegistry 类里作为成员变量的;
public class DefaultSingletonBeanRegistry
extends SimpleAliasRegistry
implements SingletonBeanRegistry {
/** Cache of singleton factories: bean name to ObjectFactory. */
private Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */
private Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
/** Cache of singleton objects: bean name to bean instance. */
private Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// ...
}
- 三级缓存 singletonFactories:可以看到存的是 ObjectFactory 对象,第三级缓存可以根据对象是否需要创建代理而提前创建出代理对象;或者是创建出普通对象;
- 二级缓存 earlySingletonObjects:顾名思义,它存储的是一个早期对象,存的是半成品对象或者半成品对象的代理对象,用来解决对象创建过程中的循环依赖问题;(这里为什么说是一个半成品对象,因为这里存储的对象的属性可能没有注入完全);
- 一级缓存 singletonObjects:这里存的就是成品对象,实例化和初始化都完成了,我们项目中使用的对象都是在一级缓存中获取的,一级缓存中存放代理对象,普通对象;
三. getBean()流程
我们通过 BeanFactory 的 getBean() 看一下三级缓存的全流程;
直接进入到 AbstractBeanFactory 的 getBean();
// --------------------------- AbstractBeanFactory ---------------------------
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
// --------------------------- AbstractBeanFactory ---------------------------
protected <T> T doGetBean(
String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
// ...
// 我们直接看主流程
// Create bean instance.
if (mbd.isSingleton()) {
// 这里调用 DefaultSingletonBeanRegistry#getSingleton()
// 参数一为 beanName
// 参数二为 ObjectFactory 函数式对象
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// ...
}
在 AbstractBeanFactory#doGetBean() 中调用了 DefaultSingletonBeanRegistry#getSingleton(),并且这个 getSingleton() 的参数二是一个 ObjectFactory 函数式对象,这个函数式对象的实现逻辑是 return createBean();
我们先看 DefaultSingletonBeanRegistry#getSingleton();
// ------------------------ DefaultSingletonBeanRegistry -----------------------
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
// 1. 先从一级缓存中去获取
// 如果获取到了 bean 对象,直接返回
// 没有获取到 bean 对象的话,进入后续创建 bean 对象流程
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException();
}
// ...
try {
// 2. 调用 ObjectFactory 对象的 getObject() 创建得到 bean 对象
// 从上述分析我们知道最终实现是 return createBean()
// 我们需要看 createBean() 流程
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} finally {
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 3. 创建 bean 成功的情况下
// 将 bean 对象放入到一级缓存 singletonObjects 中
// 并将 beanName 对应的值从二级缓存、三级缓存中移除
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
// ------------------------ DefaultSingletonBeanRegistry -----------------------
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 将 bean 对象放入一级缓存中
// 并将 beanName 对应的值从二级缓存、三级缓存中移除
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
核心实现是 ObjectFactory 的 createBean(),我们看 createBean() 逻辑;
// --------------------- AbstractAutowireCapableBeanFactory -------------------
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
RootBeanDefinition mbdToUse = mbd;
// ...
try {
// 调用 doCreateBean() 创建出 bean 对象,并返回该 bean 对象
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
} catch (Throwable ex) {
throw new BeanCreationException();
}
}
// --------------------- AbstractAutowireCapableBeanFactory -------------------
protected Object doCreateBean(String beanName, RootBeanDefinition mbd,
Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 1. 实例化对象
// 根据合适的构造方法构造出实例 bean 对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 2. 是否应该使用三级缓存,一般情况下都会使用三级缓存
boolean earlySingletonExposure = (mbd.isSingleton() &&
this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 3. 将 beanName 和对应的函数式对象 ObjectFactory 放入到三级缓存中
// 该 ObjectFactory 已经拿到了刚刚实例化好的 bean 对象,只不过只执行了构造函数
// 该 ObjectFactory 的 getObject() 实现是调用 getEarlyBeanReference()
addSingletonFactory(beanName,
() -> getEarlyBeanReference(beanName, mbd, bean));
}
// 4. 初始化 Bean 对象
Object exposedObject = bean;
try {
// 4.1 属性注入
// 如果 A 依赖 B,getBean(A) 时会去调 getBean(B)
// 如果 A、B 出现循环依赖,会出现 getBean(A) -> getBean(B) -> getBean(A) 的情况
populateBean(beanName, mbd, instanceWrapper);
// 4.2 初始化 bean 对象
// 这里会执行一些 BeanPostProcessor 的后处理方法
// 我们熟悉的 Spring AOP 就是在这里生成的代理类对象的
// 如 @Transactional 使用的后处理器是 AbstractAutoProxyCreator
// 如 @Async 使用的后处理器是 AbstractAdvisingBeanPostProcessor
// 虽然都是生成 AOP 对象,但是这两者在处理循环依赖时处理逻辑不一样,后面细讲
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
throw ex;
}
if (earlySingletonExposure) {
// 5. 决定 getBean(A) 是返回 bean 对象还是抛出异常
// 参数二是 false
// 从一级缓存或者二级缓存中获取 bean 对象
// 走到这里一般是尝试从二级缓存中获取 bean 对象
// 这里比较绕,我们后面再讲
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping &&
hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>();
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException();
}
}
}
}
// 6. 注册删除 bean 逻辑
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException();
}
// 7. 返回 bean 对象
return exposedObject;
}