Spring循环依赖 | Spring三级缓存 | 看完必有收获
Posted 做猪呢，最重要的是开森啦
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring循环依赖 | Spring三级缓存 | 看完必有收获相关的知识，希望对你有一定的参考价值。
文章目录
0. 举个栗子：
所谓循环依赖，就是A中依赖了B，而B又依赖了A，如下
@Service
public class BeanServiceA {
private String name = "serviceA";
@Autowired
BeanServiceB beanServiceB;
public void testMethod() {
System.out.println();
}
}
@Service
public class BeanServiceB {
private String name = "serviceA";
@Autowired
BeanServiceA beanServiceA;
}
@Component
public class AopAspectConfiguration {
@Pointcut("execution(public * com.aop.BeanServiceA.*(..))")
public void pointcut() {
}
@Before("pointcut()")
public void deBefore(JoinPoint joinPoint) throws Throwable {
System.out.println("ARGS : " + Arrays.toString(joinPoint.getArgs()));
}
}
本文举栗中A要进行代理，而B不需要
1. Bean创建过程及循环依赖解决：
这部分需要对Bean创建的生命周期有所了解，可以参考生命周期系列文章
·
先介绍一下循环依赖涉及的重点方法DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存singletonObjects获取bean
Object singletonObject = this.singletonObjects.get(beanName);
// 一级缓存没有，判断该bean是否在创建中，通过Set的contains来判断
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从二级缓存中获取bean
singletonObject = this.earlySingletonObjects.get(beanName);
// 二级缓存没有&&允许提前引用
if (singletonObject == null && allowEarlyReference) {
// 从三级缓存中获取lambda表达式
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用三级缓存的lambda表示获取早期不完整对象
singletonObject = singletonFactory.getObject();
// 写入二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
// 三级缓存移除该bean的lambda表达式
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
1.1. BeanServiceA的创建:
在创建bean时，会调用doGetBean方法，首先通过getSingleton方法从缓存中看是否能获取到该bean
- a. 先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中，显然初次创建时不成立，即getSingleton返回null
- b. 调用第14行的getSingleton方法触发createBean回调，进行bean的生命周期
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
... ... ...
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
... ... ...
}else {
... ... ...
try {
... ... ...
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
... ... ...
}
return (T) bean;
}
在第14行的getSingleton，会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
... ... ...
// 会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
beforeSingletonCreation(beanName);
... ... ...
try {
// lambda表达式回到createBean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
... ... ...
}
return singletonObject;
}
}
1.1.1. 实例化BeanServiceA不完整对象:
- 一般通过createBeanInstancec实例化不完整的BeanServiceA对象
- 将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
- 属性填充BeanServiceB
- 初始化BeanServiceA时调用AOP后置处理器进行AOP处理
- 处理提前暴露的场景，保证返回同一个代理对象
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
... ... ...
if (instanceWrapper == null) {
// a. 一般通过createBeanInstancec实例化不完整的BeanServiceA对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
... ... ...
// 默认单例&&默认循环引用&&该bean正在创建，条件成立
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
... ... ...
// b. 将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// c. 属性填充BeanServiceB
populateBean(beanName, mbd, instanceWrapper);
// d.初始化时调用AOP后置处理器进行AOP处理
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
... ... ...
// e.处理提前暴露的场景，保证返回同一个代理对象
if (earlySingletonExposure) {
// 见上文第1节的节速，由于第二个参数是false，所以只会查到第二季缓存
// 所以这里就是查看第二级缓存能不能取到值，取到就意味着涉及提前AOP
Object earlySingletonReference = getSingleton(beanName, false);
// 涉及提前AOP，从二级缓存中获取提前AOP的代理对象
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// 保证循环依赖且涉及AOP时，返回同一个代理对象，下文有结束
exposedObject = earlySingletonReference;
}
... ... ...
}
}
return exposedObject;
}
addSingletonFactory将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
// 将不完整对象以及BeanDefinition代表的lambda表达式写入三级缓存
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
1.1.2. 属性填充BeanServiceB:
关于属性填充方法的详细介绍可参考链接：属性填充populateBean
当填充BeanServiceB会重复上文第1节中的内容：
- a. 先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中，显然初次创建时不成立，即getSingleton返回null
- b. 调用第14行的getSingleton方法触发createBean回调，进行bean的生命周期
- c. 实例化BeanServiceB的不完整对象，并将lambda写入三级缓存
- d. 属性填充BeanServiceA（见下文1.1.2.1）
- e. initializeBean初始化BeanServiceB
1.1.2.1. 循环依赖处理属性填充BeanServiceA:
同样，会重复上文第1节的内容，但此时会有不一样的处理：
a). 先从一级缓存singletonObjects中获取，发现获取不到，然后看是否在创建中
·
显然正在创建，singletonsCurrentlyInCreation有beanServiceA
b). 从二级缓存中获取 → 获取不到 → 从三级缓存获取 → lambda表达式回调（见下文1.1.2.1.1）
c). 将不完整对象BeanServiceA写入二级缓存，三级缓存删除该对象lambda表达式（上文1中getSingleton方法）
d). 返回不完整的BeanServiceA对象
1.1.2.1.1. AbstractAutoProxyCreator#getEarlyBeanReference:
这里涉及Aop，关于Aop源码有兴趣可以查看链接：Aop代理过程
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;
// 调用后置处理器的getEarlyBeanReference进行提前暴露bean
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
lambda回调会调用后置处理器的getEarlyBeanReference，来获取不完整的bean
- 如果当前依赖的bean不涉及Aop，则返回实例化时创建的不完整bean对象
- 如果当前依赖的bean涉及Aop，则返回一个代理该不完整bean的代理对象
- 本处返回实例化创建的不完整beanServiceA对象
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 写入earlyProxyReferences，在后面postProcessAfterInitialization会用到
this.earlyProxyReferences.put(cacheKey, bean);
// 判断是否创建代理对象
return wrapIfNecessary(bean, beanName, cacheKey);
}
1.1.2.2. 初始化BeanServiceB时调用AOP后置处理器进行AOP处理
属性填充beanServiceA后，此时填充的beanServiceA是不完整的对象
在initializeBean初始化调用后置处理器的postProcessAfterInitialization方法
由于BeanServiceB不涉及AOP，所以返回原始的B对象，此时填充的beanServiceA还是不完整的对象
- B不涉及提前AOP，所以earlyProxyReferences没有beanServiceB（见上文1.1.2.1.1）
- remove返回null，条件成立，执行wrapIfNecessary方法
- 由于beanServiceB不涉及AOP，所以返回原始的B对象
1.1.2.3. 处理提前暴露的场景，保证返回同一个代理对象
BeanServiceB不涉及AOP，
getSingleton返回null，所以直接返回原始对象exposedObject
1.1.2.4. BeanServiceB对象写入一级缓存，移除二、三级缓存
beanServiceB生命周期执行完，返回到1.1节第14行的getSingleton方法，此时返回的还是不完整的beanServiceB对象
·
singletonsCurrentlyInCreation移除bean，表明不再是正在创建的bean
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
... ... ...
// 会将当前beanName放入singletonsCurrentlyInCreation，表示当前bean正在创建
beforeSingletonCreation(beanName);
... ... ...
try {
// lambda表达式回到createBean
singletonObject = singletonFactory.getObject();
newSingleton = true;
... ... ..
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// singletonsCurrentlyInCreation中移除beanName，表示该bean不是正在创建了
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 将不完整的beanServiceB对象写入一级缓存，移除二、三级缓存
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
beanServiceB“不完整对象”写入一级缓存，移除二、三级缓存
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);
}
}
1.1.3. BeanServiceA属性填充BeanServiceB（完整bean）
此时ioc容器已经有了beanServiceB，虽然暂时还是不完整的
·
但是，当beanServiceA填充完beanServiceB后，使得互相循环依赖对方，此时二者都变成了完整的bean
·
此时一级缓存的beanServiceB也由不完整的bean变成了完整的bean，因为是同一个地址
A涉及AOP，所以循环依赖时，A会进行提前AOP，所以B中填充的是A的代理对象
·
当A填充完B时，构成互相循环依赖对方
1.1.4. 初始化BeanServiceA时调用AOP后置处理器进行AOP处理
- 由于beanServiceA提前AOP了，所以所以earlyProxyReferences有beanServiceA（见上文1.1.2.1.1）
- remove返回原始的bean，即earlyProxyReferences对应的value，条件不成立，直接==返回原始bean ==
1.1.5. 处理提前暴露的场景，保证返回同一个代理对象
beanServiceA涉及提前AOP，
getSingleton返回保存在二级缓存中提前AOP的代理对象A
这里面有exposedObject == bean判断，这就是为什么上述1.1.4中AOP后置处理器返回原始bean的原因
`
条件成立，将代理对象赋值放回，保证返回同一个代理对象，即B中的A和A都是同一个代理对象
1.2. BeanServiceA完整对象写入一级缓存，移除二、三级缓存
同1.1.2.4节一样，beanServiceA生命周期执行完，会将beanServiceA写入一级缓存，移除二、三级缓存
2. 整体流程：
2.1. 涉及循环依赖&&涉及AOP的场景
该场景大概流程如下图，详细可见上文介绍
2.2. 不涉及AOP的循环依赖场景
- 不涉及AOP，那么A进行lambda表达式回调后返回就A的原始对象，保存到二级缓存中，所以B属性填充后的A也是A的原始对象
- 当A属性填充完后，A和B相互依赖，使得二者都是完整的对象，可见上文1.1.3的图
2.3. 不涉及循环依赖的AOP场景
- 不涉及循环依赖，也就不涉及提前AOP，正常A经过实例化–属性填充–初始化
- 在初始化时通过AOP后置处理器创建代理对象返回，在上文1.1.5节，二级缓存返回null，最终直接返回代理对象A
2.4. 不涉及循环依赖&&不涉及AOP场景
- 不涉及循环依赖，也就不涉及提前AOP，正常A经过实例化–属性填充–初始化
- 不涉及AOP，则在初始化时通过AOP后置处理器直接返回原始A对象，在上文1.1.5节，二级缓存返回null，最终返回原始A对象
3. 要点讲解：
3.1. 什么是三级缓存？
// 一级缓存，用于存放完整的单例bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//二级缓存，用于存放原始（不完整）的对象，用于解决循环依赖
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 三级缓存，存放函数式接口，用于解决循环依赖
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
3.2. 为什么二三级缓存用HashMap，而不像一级缓存使用ConcurrentHashMap
现有逻辑是，二三级缓存的操作是在synchronized代码块里面操作的（见下方10、11行代码）
·
这已经是线程安全的了，所以没有必要使用ConcurrentHashMap
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 手撕Spring源码，详细理解Spring循环依赖及三级缓存