当 Spring 循环依赖碰上 Aysnc,调试过程中出现 BeanCurrentlyInCreationException,有点意思

开心一刻

前两天有个女生加我,我同意了

第一天,她和我聊文学,聊理想,聊篮球,聊小猫小狗

第二天,她和我说要看我腹肌

吓我一跳,我反手就删除拉黑,我特喵一肚子的肥肉,哪来的腹肌!

循环依赖

关于 Spring 的循环依赖,我已经写了 4 篇

Spring 的循环依赖,源码详细分析 → 真的非要三级缓存吗

再探循环依赖 → Spring 是如何判定原型循环依赖和构造方法循环依赖的

三探循环依赖 → 记一次线上偶现的循环依赖问题

四探循环依赖 → 当循环依赖遇上 BeanPostProcessor,爱情可能就产生了!

此时你们是不是有点慌,莫非要来五探了,还有完没完了?我先给你们打一针强心剂,今天我们不聊循环依赖,而是来看看在调试循环依赖过程中遇到的小插曲

首先声明下,这是来自园友(@飞的很慢的牛蛙 )的素材,已经过他同意

循环依赖案例很简单

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

点一下 circletoStrng(),然后我们 F8 一下(代码 606 行执行完毕,来到 607 行,607行并未执行),再去看第二级缓存

第二级缓存竟然有元素了,那第三级缓存的 circle 还存在吗

很显然,是有什么操作将第三级缓存中的 circle 提前曝光到第二级缓存了,回顾下这期间我们做了哪些操作?

  1. 点了 circle 的 toString()
  2. 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);
    }
}

重复之前的调试过程(记得去找第一级缓存中的 loopcircle,然后点其 toString()),取消所有断点后 F9BeanCurrentlyInCreationException 它就来了

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,导致半成品对象提前曝光了

我们来梳理下 CircleLoop 的实例创建过程。根据 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 实例就清楚了

总结

  1. Spring 调试过程中不要随便去点代理对象的 toString,它可能会导致对象的提前曝光,打乱了 Spring bean 的创建过程,最终导致异常;抛异常倒是够直观,就怕不抛异常,然后运行过程中出现各种奇葩问题

  2. IDEA 调试配置

    有些版本默认是勾上的,这就会导致调试后过程中,我们去查看对象的时候自动调用对象的 toString 方法,可能引发一些异常,比如上文中介绍的循环依赖 circle 提前曝光的问题

  3. 实际工作中,大家基本遇不到文中的情况,看看图个乐就行