开心一刻
前两天有个女生加我,我同意了
第一天,她和我聊文学,聊理想,聊篮球,聊小猫小狗
第二天,她和我说要看我腹肌
吓我一跳,我反手就删除拉黑,我特喵一肚子的肥肉,哪来的腹肌!
循环依赖
关于 Spring 的循环依赖,我已经写了 4 篇
Spring 的循环依赖,源码详细分析 → 真的非要三级缓存吗
此时你们是不是有点慌,莫非要来五探了,还有完没完了?我先给你们打一针强心剂,今天我们不聊循环依赖,而是来看看在调试循环依赖过程中遇到的小插曲
首先声明下,这是来自园友(@飞的很慢的牛蛙 )的素材,已经过他同意
循环依赖案例很简单
pom.xml
xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.qsl</groupId>
<artifactId>spring-circle</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>spring-circle-async</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
</dependencies>
</project>
Spring 的版本用的是:5.2.12.RELEASE
Circle.java
java
/**
* @author: 青石路
*/
@Component
public class Circle {
@Autowired
private Loop loop;
public Loop getLoop() {
return loop;
}
public void sayHello(String name) {
System.out.println("circle sayHello, " + name);
}
}
Loop.java
/**
* @author: 青石路
*/
@Component
public class Loop {
@Autowired
@Lazy
private Circle circle;
public Circle getCircle() {
return circle;
}
public void sayHello(String name) {
System.out.println("loop sayHello, " + name);
}
}
为了兼容 Spring 的各种版本,加了 @Lazy
CircleTest.java
java
/**
* @author: 青石路
*/
@ComponentScan(basePackages = "com.qsl")
public class CircleTest {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(CircleTest.class);
Circle circle = ctx.getBean(Circle.class);
Loop loop = ctx.getBean(Loop.class);
System.out.println(circle.getLoop());
System.out.println(loop);
}
}
main
跑起来是没问题滴
完整代码:spring-circle-async
调试插曲
正常调试,想看看 Spring 是如何处理循环依赖的;在 AbstractAutowireCapableBeanFactory#doCreateBean
的 606 行打个断点,同时给断点加个 Condition
开始调试,为了方便查看三级缓存中的内容,我们添加三个 watch
将三级缓存都添加进来
此时我们来看第二级缓存 earlySingletonObjects
是没有内容的,我们再看下第三级缓存
circle 怎么会到第三级缓存中,跟循环依赖有关;接下来去看下第一级缓存,找到 loop
点一下 circle
的 toStrng()
,然后我们 F8
一下(代码 606 行执行完毕,来到 607 行,607行并未执行),再去看第二级缓存
第二级缓存竟然有元素了,那第三级缓存的 circle
还存在吗
很显然,是有什么操作将第三级缓存中的 circle
提前曝光到第二级缓存了,回顾下这期间我们做了哪些操作?
- 点了 circle 的 toString()
- F8,执行了代码 606 行:if (earlySingletonExposure)
这就很明显了,肯定是点了 circle 的 toString() 导致的,怎么验证了?其实很简单,重新开始调试,来到 AbstractAutowireCapableBeanFactory 606 行后,啥也别动,直接在 DefaultSingletonBeanRegistry#getSingleton
182 行打个断点
然后再回到 AbstractAutowireCapableBeanFactory 606,再去第一级缓存中找 loop,然后点击它的 circle 的 toString,IDEA 会提示如下信息
Skipped breakpoint at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry:182 because it happened inside debugger evaluation Troubleshooting guide
翻译过来就是
忽略 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry:182 的断点,因为它发生在调试器内部,详情请看 Troubleshooting guide
提前曝光就提前曝光呗,放开断点,程序能够正常执行完毕,有什么关系呢?那我就再给你们加点料,CircleTest.java 上加上 @EnableAsync
java
/**
* @author: 青石路
*/
@ComponentScan(basePackages = "com.qsl")
@EnableAsync
public class CircleTest {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(CircleTest.class);
Circle circle = ctx.getBean(Circle.class);
Loop loop = ctx.getBean(Loop.class);
System.out.println(circle.getLoop());
System.out.println(loop);
}
}
Circle.java 的 sayHello 方法上加上 @Async
java
/**
* @author: 青石路
*/
@Component
public class Circle {
@Autowired
private Loop loop;
public Loop getLoop() {
return loop;
}
@Async
public void sayHello(String name) {
System.out.println("circle sayHello, " + name);
}
}
重复之前的调试过程(记得去找第一级缓存中的 loop
的 circle
,然后点其 toString()
),取消所有断点后 F9
,BeanCurrentlyInCreationException
它就来了
java
Exception in thread "main" org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'circle': Bean with name 'circle' has been injected into other beans [loop] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:623)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:516)
at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:324)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:322)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:897)
at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:879)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:551)
at org.springframework.context.annotation.AnnotationConfigApplicationContext.<init>(AnnotationConfigApplicationContext.java:89)
at com.qsl.CircleTest.main(CircleTest.java:16)
异常信息已经说的很清楚了
创建名为 circle 的bean时出错:注入给 loop bean 的是 circle 的代理实例,而非最终进入到第一级缓存的 circle bean
相当于注入给 loop bean 的是 circle 的代理对象实例,而提前曝光的是 circle 的半成品对象,两处不一致;究其原因还是我们操作 circle 的 toString,导致半成品对象提前曝光了
我们来梳理下 Circle
和 Loop
的实例创建过程。根据 Spring
的扫描规则,Circle 是被先扫描到的
三探循环依赖 → 记一次线上偶现的循环依赖问题 有介绍扫描规则
所以 Circle
实例会先被创建,因为 @Async
(底层实现:代理),第三级缓存提前创建 Circle 代理对象
接着填充 Circle 半成品对象的属性 Loop loop
,所以继续创建 Loop 实例,第三级缓存提前创建 Loop 代理对象(用不到,后续直接 remove)
此时我们看下当前线程的栈帧
接着填充 Loop 半成品对象的属性 Circle circle
,此时 circle 还没创建完,所以填充给 loop 的 circle 肯定是第三级缓存中 circle 的代理对象
填充完后,loop 实例创建完毕,会添加到第一级缓存中,并移除第三级缓存中的 loop(呼应前面说到的:用不到,后续直接 remove)和第二级缓存中的 loop(没有)
此时 loop 来到了第一级缓存,成为了 成品
实例,而 circle 还在第三级缓存中,第二级缓存仍是空;loop 实例创建好之后,回到 circle 的属性填充,将 loop 成品填充给半成品 circle
初始化 circle 完成后,此时 circle 的曝光对象(exposedObject)是
此时已经到 606 行了,大家知道该做什么了吧,去第一级缓存中找到 loop,然后点击它的 circle 的 toString()
然后我们进入 getSingleton
方法,此时 circle 在缓存中的位置发生了变化
正是这个变化,导致了接下来的流程发生了变化;我们继续往下看,getSingleton 方法返回了二级缓存中的 circle,而非正常流程下的 null
exposedObject
不等于 bean
,会来到 else if 分支判断是否有依赖 circle 的 bean,很显然有(loop),最后就来到异常分支
java
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
凡是涉及到代理的,最终在第一级缓存中的都是实例的代理对象,比如 circle,我们取消掉所有断点,只在 CircleTest.java 上打一个断点,看看 circle 和 loop 实例就清楚了
总结
-
Spring 调试过程中不要随便去点代理对象的
toString
,它可能会导致对象的提前曝光,打乱了 Spring bean 的创建过程,最终导致异常;抛异常倒是够直观,就怕不抛异常,然后运行过程中出现各种奇葩问题 -
IDEA 调试配置
有些版本默认是勾上的,这就会导致调试后过程中,我们去查看对象的时候自动调用对象的
toString
方法,可能引发一些异常,比如上文中介绍的循环依赖 circle 提前曝光的问题 -
实际工作中,大家基本遇不到文中的情况,看看图个乐就行