002.Spring 使用 Async 导致循环创建异常

最新推荐文章于 2024-11-05 14:54:53 发布
最新推荐文章于 2024-11-05 14:54:53 发布
阅读量358 收藏 2
点赞数 3
分类专栏： 疑难杂症 文章标签： spring
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/masteryourself/article/details/106730908
版权

1. 场景前提

假设有这样一个场景：在一个被 Spring 容器管理的 SomeService 类中定义了两个方法，一个方法叫 doSomething()，另一个方法叫 sendMsg()，其中 sendMsg() 是处理短信业务的，现在在 doSomething() 中调用 sendMsg()，如何才能使短信业务变成异步呢

场景一：如果为同步处理情况下，可以直接使用 this.sendMsg() 进行调用

场景二：当把 sendMsg 改为异步后，考虑到 Spring 中做增强的是代理类而非方法，所以通过 @Autowired 把当前类注入到自己的属性中呢，结果抛出了 BeanCurrentlyInCreationException 异常

场景三：在网上一顿百度之后，大多数的解决方案都是加上 @Lazy 注解，于是加上之后项目稀里糊涂地又好了

场景四：加上 @Lazy 注解是否是最优的解法呢？其实更推荐将异步 @Async 的处理单独放到一个类中，以此解决循环引用，代码也变得更加优美

2. 环境搭建

代码已经上传至 https://github.com/masteryourself/diseases ，详见 diseases-spring/diseases-spring-async-cycle 工程

2.1 代码
1. SomeService
@Service
public class SomeService {

    /***********************************    场景一   ***********************************/
    /*public void doSomething() {
        System.out.println(Thread.currentThread().getName() + "：do doSomething finish");
        // 直接同步调用发短信方法
        this.sendMsg();
    }

    public void sendMsg() {
        System.out.println(Thread.currentThread().getName() + "：do sendMsg() method");
    }*/


    /***********************************    场景二   ***********************************/
    /**
     * 考虑到这里如果直接使用 this.sendMsg() 就不会有代理功能, 因为 Spring 增强的是代理类, 而非方法, this 是指对象本身
     * 所以自作聪明地使用了 {@link Autowired} 注入了代理对象, 然后使用这个对象去调用 sendMsg() 方法, 结果抛出了异常
     * 当此类中添加 {@link Async} 这种基于 {@link BeanPostProcessor} 去生成 aop 动态代理的组件时, 就会抛出循环引用异常
     */
    /*@Autowired
    private SomeService someService;

    public void doSomething() {
        System.out.println(Thread.currentThread().getName() + "：do doSomething finish");
        // 使用 someService 调用, 发现代理生效
        someService.sendMsg();
    }

    @Async
    public void sendMsg() {
        System.out.println(Thread.currentThread().getName() + "：do sendMsg() method");
    }*/


    /***********************************    场景三   ***********************************/
    /**
     * 使用 {@link Lazy} 避免
     * @Lazy 可以理解为在需要 bean 的时候才会去获取真正的 bean 对象, 而不是启动时候就解决其依赖问题, 这样自然就避免了循环依赖
     */
    /*@Lazy
    @Autowired
    private SomeService someServiceProxy;

    public void doSomething() {
        System.out.println(Thread.currentThread().getName() + "：do doSomething finish");
        // 使用 someService 调用, 发现代理生效
        someServiceProxy.sendMsg();
    }

    @Async
    public void sendMsg() {
        System.out.println(Thread.currentThread().getName() + "：do sendMsg() method");
    }*/

    /***********************************    场景四   ***********************************/
    /**
     * 重新定义一个组件, 把代理对象和本身分开, 勿要自作聪明, 在自己的类中注入自己
     */
    @Autowired
    private SomeServiceAsyncHandler someServiceAsyncHandler;

    @Async
    public void doSomething() {
        System.out.println(Thread.currentThread().getName() + "：do doSomething finish");
        someServiceAsyncHandler.sendMsg();
    }

}
2. SomeServiceAsyncHandler
@Service
public class SomeServiceAsyncHandler {

    public void sendMsg() {
        System.out.println(Thread.currentThread().getName() + "：do sendMsg() method");
    }

}

3. 异常剖析

3.1 错误日志

使用场景二的代码启动后将会抛出如下异常

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'asyncCycleApplication': Unsatisfied dependency expressed through field 'someService'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'someService': Bean with name 'someService' has been injected into other beans [someService] 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 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:596) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:90) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:374) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1411) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:592) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:515) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:320) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$78/1764696127.getObject(Unknown Source) ~[na:na]
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:849) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:877) ~[spring-context-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:549) ~[spring-context-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:142) ~[spring-boot-2.1.4.RELEASE.jar:2.1.4.RELEASE]
	at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:775) [spring-boot-2.1.4.RELEASE.jar:2.1.4.RELEASE]
	at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:397) [spring-boot-2.1.4.RELEASE.jar:2.1.4.RELEASE]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:316) [spring-boot-2.1.4.RELEASE.jar:2.1.4.RELEASE]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1260) [spring-boot-2.1.4.RELEASE.jar:2.1.4.RELEASE]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1248) [spring-boot-2.1.4.RELEASE.jar:2.1.4.RELEASE]
	at pers.masteryourself.diseases.spring.async.cycle.AsyncCycleApplication.main(AsyncCycleApplication.java:35) [classes/:na]
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'someService': Bean with name 'someService' has been injected into other beans [someService] 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 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:622) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:515) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:320) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$78/1764696127.getObject(Unknown Source) ~[na:na]
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:277) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1247) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1167) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:593) ~[spring-beans-5.1.6.RELEASE.jar:5.1.6.RELEASE]
	... 20 common frames omitted
3.2 异常详解
3.2.1 EnableAsync 注解

@EnableAsync -> AsyncConfigurationSelector -> ProxyAsyncConfiguration -> AsyncAnnotationBeanPostProcessor

@EnableAsync 注解实际上就是给容器中导入组件，最终会导入 AsyncAnnotationBeanPostProcessor 组件，它实际上是一个 BeanPostProcessor 类型组件，所以重点应该关注 postProcessAfterInitialization() 方法，它实际上就是帮容器中的 bean 做代理，然后返回代理对象到容器中

3.2.2 doCreateBean() 方法

根据异常信息可以定位到这个方法，下面简单分析一下这个方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
	    // 使用构造方法创建 bean 实例，经过包装后返回包装对象
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 获取 bean 对象，此时的 bean 还没有完成赋值操作，仅仅是构造出来的对象
	final Object bean = instanceWrapper.getWrappedInstance();
	
	...

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
	    // 给属性赋值
		populateBean(beanName, mbd, instanceWrapper);
		
		// 执行 bean 的初始化，在这里会执行 BeanPostProcessor 的 postProcessAfterInitialization()
		// 由于此类被标注了 @Async 注解，所以这里的 AsyncAnnotationBeanPostProcessor 组件会生效，然后返回一个代理对象
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
		
		...
		
	}

	if (earlySingletonExposure) {
	    // 从容器中获取对象，可能是一级缓存、二级缓存，这里是从二级缓存中获取的原始对象
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
		    // 注意这里的判断，exposedObject 是代理对象，bean 是原始对象，自然是不相等的，进入下面的 else 流程
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			// 这里有个 allowRawInjectionDespiteWrapping 属性开关，可以避免进入下面的校验
			// hasDependentBean(beanName) 即是判断是否依赖当前的 beanName
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				// 对依赖信息进行检查，然后抛出异常，即 Spring 默认不希望我们这么做
				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 " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}

	...
	
}
Spring@Async注解
Mr.xing的博客
04-08 1200
自定义线程池，可对系统中线程池更加细粒度的控制，方便调整线程池大小配置，线程执行异常控制和处理。在设置系统自定义线程池代替默认线程池时，虽可通过多种模式设置，但替换默认线程池最终产生的线程池有且只能设置一个（不能设置多个类继承AsyncConfigurer）。自定义线程池有如下模式：重新实现接口AsyncConfigurer继承AsyncConfigurerSupport配置由自定义的TaskExecutor替代内置的任务执行器实现接口AsyncConfigurer。
Async：in its raw version as part of a circular reference, but has eventually been wrapped
m0_62943934的博客
08-15 793
Spring的bean相互引用下，并且其中一个bean含有异步注解@Async，启动可能会出现错误：在initializeBean方法中生成异步代理对象（后置处理器org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor完成代理），原bean和代理对象是两个对象，前后bean版本不一致，故抛异常。
@Async导致Error creating bean
lurenmen的博客
04-22 320
项目启动失败，由于方法中由循环依赖，@Async注解导致spring处理循环依赖失效
Bean with name ‘‘ has been injected into other beans [] in its raw version as part of a circular ref
weixin_44188105的博客
09-28 9871
Bean with name '' has been injected into other beans [] in its raw version as part of a circular ref
Spring AOP 循环应用(This means that said other beans do not use the final version of the bean..)
水神
09-14 2万+
在做spring AOP时，总发现 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 'getBeanNamesOfType' with the 'allow
Spring循环引用-@Async注解启动报错分析
liangbo7的博客
12-18 4225
Spring循环引用-@Async注解启动报错分析
sping循环依赖：but has eventually been wrapped. This means that said other beans do not use the final
weixin_42036942的博客
08-06 2483
spring循环依赖
带有@Transactional和@Async的循环依赖问题
12-21
在我们的例子中，`@Transactional`和`@Async`同时存在，导致了Spring创建了两种不同类型的代理：一种是事务代理，用于管理事务；另一种是异步代理，用于实现方法的异步执行。当Spring试图创建`TransationServiceImpl...
Spring @Async深度解析：使用、原理与常见问题解决方案
如果异步任务A依赖于异步任务B，而任务B又依赖于任务A，即使使用@Async，这种循环依赖仍然会导致问题。解决方法通常是设计良好的任务依赖关系或者采用其他技术（如消息队列）来解耦。 - **线程池限制**：如果不正确...
org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer
BLOG域名:programb.blog.csdn.net
06-23 859
这个错误消息表明在使用Spring MVC的基于注解配置（AbstractAnnotationConfigDispatcherServletInitializer）时，存在未满足的依赖。具体来说，通常表示Spring框架无法找到合适的bean来解决注入的需求，而原因在于注解的使用没有明确指定或。在Spring MVC中，当使用或注解的类时，如果需要从数据库或其他源获取数据并返回给前端，通常会涉及到结果映射（result mapping）。对于的方法，如果不显式定义或等，就需要通过来指定返回的数据类型，或者使
@Async注解提升Spring Boot项目中API接口并发能力
最新发布
晴天飛 雪的博客
11-05 1924
相反，程序会继续执行其他任务，当异步操作完成时，会调用一个预先定义好的回调函数来处理结果。总结：主程序在异步调用之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就自动结束了，导致了不完整或是没有输出任务相关内容的情况。例如，第一次调用中，任务一和任务三的执行时间都是 784 毫秒，而任务二的执行时间是 6176 毫秒，因此任务一和任务三先完成，任务二最后完成。支持链式调用，可以在一个异步操作完成后立即执行另一个异步操作，形成一个异步操作链。
Spring @Async 应用于出现循环依赖的 Bean 报错的解决方案
weixin_34310127的博客
12-13 827
2019独角兽企业重金招聘Python工程师标准>>> ...
@Async引起循环依赖报错
qq_42021442的博客
03-08 400
@Async引起循环依赖报错
SpringBoot使用@Async注解时产生的循环引用问题 in its raw version as part of a circular reference
EricXiao666的博客
10-09 4157
最近项目启动时出现一个异常问题： 重要日志信息内容如下： Bean with name ‘aService’ has been injected into other beans [bService] 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
spring 项目中抛出 in its raw version as part of a circular reference, but has eventually been wrap 异常问题
热门推荐
zhangdeing的博客
10-06 2万+
项目中存在bean自己引用自己的情况，类似如图所示 最终抛出这个异常 百度之后的解决方案在引入的TestService上加@Lazy注解即可搞定。确实也正常了。但是因为之前处理过类似的情况也是自己引用自己，只不过是在方法上加入的是@Transaction 注解，调用初始化也确实没有问题。并未出现如图所示的异常。 最终在AbstractAutowireCapableBeanFactory 中这里发现有点不一样的地方了。 由于后面会对 exposedObject 和bean 做判断，2.
使用@Async后项目启动报错
qq_42403906的博客
09-21 1594
最近在使用异步方法使用@Async项目怎么也启动不起来，最后看报错信息说是导致了循环依赖问题报错信息如下方法解决办法使用@Lazy。
PC寄存器
weixin_45650737的博客
10-13 543
连接：https://docs.oracle.com/javase/specs/jvms/se8/html/ 寄存器存储指令相关的线程信息，CPU只有把数据装载到寄存器才能运行。 JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。 作用：线程独有，用来存储指向下一条指令的地址，也即将要执行的指令代码，由执行引擎读取下一条指令！ 介绍： 他是一块很小的内存空间，几乎可以忽略不计，也是运行速度最快的存储区域。 在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。
Spring Boot 2.0.0 升级到2.4.1 循环依赖问题的解决
飞一站的博客
09-16 4724
目录 Spring Boot 2.0.0 升级到2.4.1 循环依赖问题的解决 描述 分析 第一层原因 第二层原因 第三层原因 第四层原因 第五层原因 第六层原因 第七层原因 最终原因 解决方案 相关各版本的比对 Spring Boot 2.0.0.release + Druid 1.19 Spring Boot 2.4.1 + Druid 1.19 Spring Boot 2.4.1 + Druid 1.2.5 Spring Boot 2.4.1 + Druid 1.2.
spring循环引用的问题
zgmzyr的专栏
02-13 2万+
转载于：http://blog.xiaocaihua.com/archives/2010/10/problem-of-spring-circle-reference.html     很久没写技术贴了，这两天被spring的循环引用搞死了，发文记之。 前几天，项目结构做了调整，把我所在的项目代码嵌入另一个项目，然后就杯具了，症状如下： Bean with name ‘xxxServi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值