码神崛起之Spring循环依赖终极一战。
博客: https://springlearn.cn
一日一句毒鸡汤
问世间钱为何物,只叫人生死相许。!😄
写文章不容易,如果感觉还行,请点个关注,点关注不迷路。
一、什么是循环依赖
这种简单的问题,直接伪代码吧。
@Servicepublic class A { @Autowired private B b;}@Servicepublic class B { @Autowired private A a;}
我中有你,你中有我。
二、解决循环依赖思路
思路其实非常简单还是用伪代码来说明
A a = new A();B b = new B();a.setB(b);b.setA(a);
思路就是这么简单,先分别把A和B给实例化。
这时候实例化的A和B仅仅是完成了实例化,内部的属性其实都没有。
只有当执行了3、4行才算正常完成。
A a = new A();B b = new B();a.setB(b);b.setA(a);
通过上面的代码我们总结下,要想实现循环注入。首先要满足第一个条件。
- 能被实例化
- 有空构造
- 或有构造且构造参数满足能被实例化。
好了,知道这点就成了,相信让你来实现循环注入,应该也可以了吧。其实就这么简单 ?
那我们来看Spring如何来实现的。相信看完你就头大了。但是没关系,基本原理你已经知道了。
带着这个思路来看Spring的源码就简单了。
三、Spring如何解决循环依赖
首先我们要知道Spring中的bean, 有两种形式。
- 第一种是单例。所谓单例就是容器中这个类,只会存在一个实例。不管你调用了多少次
getBean(String beanName)
返回的都是一个实例(因为每次都从缓存中获取的实例)。 - 第二种是原型。所谓原型就是容器中这个类,没有缓存。每次都是新建一个Bean。
在这里我们思考下,如果要你来实现循环注入,以上两种模式。你能用那一个?
要想实现循环注入,即这个Bean必须要有一个缓存的地方。不然每次都是创建,虽然能完成实例化,但是实例化后,需要注入的 bean
无法实现注入,就会陷入死循环。
这里第二个必要因素就出来了。
2. 必须要是单例
好了,知道这么多我们开始看源码吧。
3.1 Spring中创建Bean的步骤
- 实例化,createBeanInstance,就是new了个对象。
- 属性注入,populateBean, 就是 set 一些属性值。
- 初始化,initializeBean,执行一些 aware 接口中的方法,initMethod,AOP代理等
3.2 循环依赖三层缓存
注意看细节,每个缓存的数据类型是什么? 后面要考。
- 一级缓存
Map singletonObjects
- 如果等于空,或者当前单例正在创建中(即只完成了实例化)。就从二级缓存中获取。
- 二级缓存
Map earlySingletonObjects
- 如果等于空,就从三级缓存中获取。
- 三级缓存
Map<String, ObjectFactory> singletonFactories
- 创建Bean的一个工厂,允许容器中定义特殊的,生成Bean的方法。使用
addSingletonFactory
- 创建Bean的一个工厂,允许容器中定义特殊的,生成Bean的方法。使用
其实要想实现循环依赖只用2个缓存就行。三级缓存的意义是为了完成某些功能。至于什么功能呢? 这里先不说后面看流程。
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;}
好我们知道有这两个缓存就继续往下看源码。当 getSingleton
是 null
。继续往下走。其他源码就跳过了,不是本篇的主要内容,我们只看
解决循环依赖的核心代码。
- doCreateBean#createBeanInstance 先实现实例化。
- 当前bean是单例,不会添加到二级缓存,直接就添加到三级缓存中,注意这里不是添加的Bean,而是生成Bean的工厂方法
ObjectFactory(#getEarlyBeanReference)
。
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}
- doCreateBean#populateBean 实现属性注入
以上面的代码的例子,A创建时候被加入到了三级缓存中,然后继续执行 populateBean
。发现要依赖B。然后依次从缓存中
来找这个A。最终在三级缓存中读取到了B。然后实现注入。这里三级缓存中的 Bean
。 有可能只是完成了 new
。但是容器
不管,先完成循环注入。至于注入的东西是否是完全品还是半成品不关心,因为都是单例所以,后面在注入属性也没关系。
这里我们知道单例的用处了吧。试想一下,如果不是单例模式,而是原型模式。那么bean就必须是完全品,不然就陷入了死循环。
下面我们还用伪代码的方式再来说一篇实现思路。
// createBeanInstance先实例化,然后加入到三级缓存中A a = new A();// a在执行populateBean的时候,发现要注入属性B,于是就使用getBean。// getBean(b) 执行createBeanInstance先实例化B b = new B();// 然后加入到三级缓存中,b在执行populateBean注入属性值的时候。发现也依赖了A。// 然后从缓存中找到办成品A。于是乎B的注入就完成,然后再执行B的init方法。b.setA(a);// B完成后,则返回到A的populateBean也注入了B。然后在执行A的init方法a.setB(b);
到这里就完成了循环注入,这里有点绕,小编画了一个图,大家跟着序号来看,然后好好理解下。
通过这个图其实我们能发现一个问题。B此时从三级缓存中拿到的A是一个半成品的A。
假如B在执行初始化方法的时候,依赖A的populateBean注入的属性。那么此时一定会拿不到的。
下面写点伪代码,说一下这个问题。
3.3 发现点问题
3.3.1 半成品问题-1
@Componentpublic class A implements InitializingBean { @Autowired private B b; @Value("${a.name}") private String name; public String getName() { return name; } @Override public void afterPropertiesSet() throws Exception { System.out.println("A:" + b); }}@Componentpublic class B implements InitializingBean { @Autowired private A a; @Override public void afterPropertiesSet() throws Exception { System.out.println("B:" + a.getName()); }}
通过上图我们知道B会先执行初始化,而这里B的初始化 (图例8) 会依赖A的参数注入 (图例4) 。而B在执行初始化的时候。A(图例4没有完全完成注入)并没有完成属性注入。
那么我们此时在拿到A的getName一定是空的。
以上代码执行就是:
B:nullA:com.example.demo.B@38aa816f
3.3.2 半成品问题-2
A的BeanPostProcessor没有执行,那么假如我们想要对A进行方法代理。B在执行初始化的时候,调用A的 getName
。会成功代理上吗?
@Componentpublic class A implements InitializingBean { @Autowired private B b; private final String name = "孙悟空"; public String getName() { return name; } @Override public void afterPropertiesSet() throws Exception { System.out.println("A:" + b); }}@Componentpublic class B implements InitializingBean { @Autowired private A a; @Override public void afterPropertiesSet() throws Exception { System.out.println("B:" + a.getName()); }}@Aspect@Componentpublic class AopConfig { /** * 精确匹配类名 */ @Pointcut("within(A)") private void matchClass() { } @Before("matchClass()") public void beforeMatchClassName() { System.out.println("--------精确匹配类名-------"); }}
执行结果:
--------精确匹配类名-------B:孙悟空A:com.example.demo.B@5e01a982
发现疑问了吗? 前面我们说了,在执行B图例8的时候(b的初始化方法),A图例9并没有执行,那为什么这里会代理成功呢?
::: info 答案揭晓
这里在添加缓存的时候,并不是直接把实例添加到缓存中的。
而是将图例9的逻辑,封装到
ObjectFactory的方式添加到缓存中的。
ObjectFactory#getObject时候执行了Bean
的处理。(AOP代理等)
:::
注意: 这里并不是把所有的处理器都包装到ObjectFactory方法中,而是有选择的使用,只有实现了SmartInstantiationAwareBeanPostProcessor接口
才会放到里面。
答案就在这里,这里执行了。一些特殊逻辑的处理器。当实现了 SmartInstantiationAwareBeanPostProcessor
接口。
就可以提前对那些半成品的Bean进行处理。
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {Object exposedObject = bean;if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);}}return exposedObject;}
比如AOP的实现类。
这里我们在思考一个问题。A半成品的时候被AOP代理了一次,那么当A在执行Bean处理器的时候岂不是有要被代理一次吗?
AbstractAutoProxyCreator#getEarlyBeanReference
第一次代理时候会被加到缓存中。
public Object getEarlyBeanReference(Object bean, String beanName) { Object cacheKey = this.getCacheKey(bean.getClass(), beanName); this.earlyProxyReferences.put(cacheKey, bean); return this.wrapIfNecessary(bean, beanName, cacheKey); }
第二次时候在执行AOP后置处理器,会先判断缓存,如果缓存中存在就不在处理了。
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { if (bean != null) { Object cacheKey = this.getCacheKey(bean.getClass(), beanName); if (this.earlyProxyReferences.remove(cacheKey) != bean) { return this.wrapIfNecessary(bean, beanName, cacheKey); } } return bean; }
四、知识点总结
4.1 满足循环依赖的条件是什么?
- 必须是单例模式
- 循环依赖类,必须能实例化(空构造,或构造参数满足循环依赖条件)
4.2 循环依赖可能导致什么问题?
在执行初始化的时候,如果初始化方法,依赖循环来的属性注入参数,可能导致获取不到数据信息的情况
如上面问题1。
4.3 为什么要用三级缓存而不是二级缓存?
为了满足Spring声明周期方法,即对半成品的B进行提前生命周期处理。如实现AOP。
五、开放性问题
只使用一级缓存,和三级缓存是否就能解决循环依赖,并且满足bean一些特殊逻辑处理呢(eg:aop)?
protected Object getSingleton(String beanName, boolean allowEarlyReference) {// Quick check for existing instance without full singleton lockObject singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {synchronized (this.singletonObjects) {// Consistent creation of early reference within full singleton locksingletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null) {ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}}}return singletonObject;}
小编回答: 仅仅使用1级缓存和3级缓存完全可以的。
之所以使用2级缓存是因为三级缓存是ObjectFactory#getObject()。是每次都从工厂里面去拿。而使用了2级缓存,仅仅是为了提高性能。
而设计的。所以一单这个单例Bean完成后。会里面把二级和三级缓存给移除掉。
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);}}
最后求关注,求订阅,感谢您的阅读,本文由西魏陶渊明 版权所有。如若转载,请注明出处:程序猿升级课(https://blog.springlearn.cn/)