Latar Belakang
Beberapa masa lalu, seorang rakan sekerja memberitahu saya bahawa projeknya tidak dapat dimulakan, dan meminta saya melihatnya, dalam semangat membantu orang lain Dengan semangat yang gembira, saya mesti membantu anda dengan ini.
Jadi, saya menemui maklumat pengecualian berikut dalam konsolnya:
Pengecualian dalam utas "utama" org.springframework.beans.factory.BeanCurrentlyInCreationException: Ralat mencipta kacang dengan nama 'AService ': Kacang dengan nama 'AService' telah disuntik ke dalam kacang lain [BService] dalam versi mentahnya sebagai sebahagian daripada rujukan bulat, tetapi akhirnya telah dibungkus Ini bermakna bahawa kacang lain tidak menggunakan versi akhir kacang. Ini selalunya hasil daripada pemadanan jenis yang terlalu bersemangat - pertimbangkan untuk menggunakan 'getBeanNamesOfType' dengan bendera 'allowEagerInit' dimatikan, sebagai contoh.
di org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBeanFareCapableAutoBeanFare( AbstractableAutoBeanFare. :602)
di org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:495)
di org.springframework.beans.AbtractFactory$0 cerita. java:317)
di org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)
Fikiran pertama saya ialah apabila saya melihat Reaksi BeanCurrently ialah terdapat masalah pergantungan pekeliling. Tetapi jika anda memikirkannya dengan teliti, bukankah Spring telah menyelesaikan masalah kebergantungan bulat Mengapa ralat ini masih dilaporkan? Jadi, saya bertanya kepada wanita itu apa yang dia telah berubah, dan dia berkata bahawa dia menambahkan anotasi @Async pada kaedah itu.
Di sini saya mensimulasikan kod pada masa itu AService dan BService merujuk antara satu sama lain, dan kaedah save() AService dianotasi dengan @Async.
@Component
public class AService {
@Resource
private BService bService;
@Async
public void save() {
}
}
@Component
public class BService {
@Resource
private AService aService;
}Salin selepas log masuk
Iaitu, kod ini akan melaporkan pengecualian BeanCurrentlyInCreationException Mungkinkah apabila anotasi @Async menemui pergantungan bulat, Spring tidak dapat menyelesaikannya? Untuk mengesahkan tekaan ini, saya mengalih keluar anotasi @Async dan memulakan projek semula, dan projek itu berjaya. Jadi pada asasnya kita boleh membuat kesimpulan bahawa apabila anotasi @Async menemui kebergantungan bulat, Spring tidak dapat menyelesaikannya.
Walaupun punca masalah telah ditemui, ia menimbulkan soalan berikut:
Bagaimanakah anotasi @Async berfungsi?
Mengapa Spring tidak dapat menyelesaikan pergantungan bulat yang dihadapi oleh anotasi @Async?
Bagaimana untuk menyelesaikan masalah pengecualian pergantungan bulat?
Bagaimanakah anotasi @Async berfungsi?
Anotasi @Async dilaksanakan oleh kelas AsyncAnnotationBeanPostProcessor, yang mengendalikan anotasi @Async. Objek kelas AsyncAnnotationBeanPostProcessor disuntik ke dalam bekas Spring oleh anotasi @EnableAsync Ini adalah sebab asas mengapa perlu menggunakan anotasi @EnableAsync untuk mengaktifkan anotasi @Async.
AsyncAnnotationBeanPostProcessor
Sistem Kelas
Kelas ini melaksanakan antara muka BeanPostProcessor dan kaedah postProcessAfterInitialization, yang dilaksanakan dalam kelas AbstractorAfterInitialization, yang dilaksanakan dalam kelas Abstract. maksudnya, kaedah postProcessAfterInitialization AsyncAnnotationBeanPostProcessor akan dipanggil semula selepas fasa permulaan Bean selesai. Sebab panggilan balik ialah dalam kitaran hayat Bean, apabila pemulaan Bean selesai, kaedah postProcessAfterInitialization bagi semua BeanPostProcessor akan dipanggil semula Kodnya adalah seperti berikut:
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}Salin selepas log masuk
AsyncAnnotationBeanPostProcessor untuk kaedah postProcessAfterInitialization. :
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (this.advisor == null || bean instanceof AopInfrastructureBean) {
// Ignore AOP infrastructure such as scoped proxies.
return bean;
}
if (bean instanceof Advised) {
Advised advised = (Advised) bean;
if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
// Add our local Advisor to the existing proxy's Advisor chain...
if (this.beforeExistingAdvisors) {
advised.addAdvisor(0, this.advisor);
}
else {
advised.addAdvisor(this.advisor);
}
return bean;
}
}
if (isEligible(bean, beanName)) {
ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
if (!proxyFactory.isProxyTargetClass()) {
evaluateProxyInterfaces(bean.getClass(), proxyFactory);
}
proxyFactory.addAdvisor(this.advisor);
customizeProxyFactory(proxyFactory);
return proxyFactory.getProxy(getProxyClassLoader());
}
// No proxy needed.
return bean;
}Salin selepas log masuk
Fungsi utama kaedah ini adalah untuk memproksi secara dinamik objek yang dimasukkan sebagai parameter Apabila kelas objek yang dimasukkan sebagai parameter dianotasi dengan @Async, maka kaedah ini akan memproksi objek secara dinamik dan. akhirnya mengembalikannya Objek proksi objek parameter padam. Bagi cara untuk menentukan sama ada kaedah dianotasi dengan @Async, ia ditentukan oleh isEligible(bean, beanName). Memandangkan kod ini melibatkan pengetahuan asas proksi dinamik, ia tidak akan dihuraikan di sini.
Peranan AsyncAnnotationBeanPostProcessor
Ringkasnya, boleh disimpulkan bahawa apabila fasa permulaan selesai semasa proses penciptaan kacang, AsyncAnnotationBeanPostProcessor akan dipanggil Kaedah postProcessAfterInitialization secara dinamik memproksi objek kelas yang diberi penjelasan dengan @Async, dan kemudian mengembalikan objek proksi.
虽然这里我们得出@Async注解的作用是依靠动态代理实现的，但是这里其实又引发了另一个问题，那就是事务注解@Transactional又或者是自定义的AOP切面，他们也都是通过动态代理实现的，为什么使用这些的时候，没见抛出循环依赖的异常？难道他们的实现跟@Async注解的实现不一样？不错，还真的不太一样，请继续往下看。
AOP是如何实现的？
我们都知道AOP是依靠动态代理实现的，而且是在Bean的生命周期中起作用，具体是靠 AnnotationAwareAspectJAutoProxyCreator 这个类实现的，这个类会在Bean的生命周期中去处理切面，事务注解，然后生成动态代理。这个类的对象在容器启动的时候，就会被自动注入到Spring容器中。
AnnotationAwareAspectJAutoProxyCreator 也实现了BeanPostProcessor，也实现了 postProcessAfterInitialization 方法。
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
//生成动态代理，如果需要被代理的话
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}Salin selepas log masuk
通过 wrapIfNecessary 方法就会对Bean进行动态代理，如果你的Bean需要被动态代理的话。
AnnotationAwareAspectJAutoProxyCreator作用
也就说，AOP和@Async注解虽然底层都是动态代理，但是具体实现的类是不一样的。一般的AOP或者事务的动态代理是依靠 AnnotationAwareAspectJAutoProxyCreator 实现的，而@Async是依靠 AsyncAnnotationBeanPostProcessor 实现的，并且都是在初始化完成之后起作用，这也就是@Async注解和AOP之间的主要区别，也就是处理的类不一样。
Spring是如何解决循环依赖的
Spring在解决循环依赖的时候，是依靠三级缓存来实现的。我曾经写过一篇关于三级缓存的文章，如果有不清楚的小伙伴可以 关注微信公众号 三友的java日记，回复 循环依赖 即可获取原文链接，本文也算是这篇三级缓存文章的续作。
简单来说，通过缓存正在创建的对象对应的ObjectFactory对象，可以获取到正在创建的对象的早期引用的对象，当出现循环依赖的时候，由于对象没创建完，就可以通过获取早期引用的对象注入就行了。
而缓存ObjectFactory代码如下：
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
Salin selepas log masuk
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}Salin selepas log masuk
所以缓存的ObjectFactory对象其实是一个lamda表达式，真正获取早期暴露的引用对象其实就是通过 getEarlyBeanReference 方法来实现的。
getEarlyBeanReference 方法:
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;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}Salin selepas log masuk
getEarlyBeanReference 实现是调用所有的 SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference 方法。
而前面提到的 AnnotationAwareAspectJAutoProxyCreator 这个类就实现了 SmartInstantiationAwareBeanPostProcessor 接口，是在父类中实现的：
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
this.earlyProxyReferences.add(cacheKey);
}
return wrapIfNecessary(bean, beanName, cacheKey);
}Salin selepas log masuk
这个方法最后会调用 wrapIfNecessary 方法，前面也说过，这个方法是获取动态代理的方法，如果需要的话就会代理，比如事务注解又或者是自定义的AOP切面，在早期暴露的时候，就会完成动态代理。
这下终于弄清楚了，早期暴露出去的原来可能是个代理对象，而且最终是通过AnnotationAwareAspectJAutoProxyCreator这个类的getEarlyBeanReference方法获取的。
但是AsyncAnnotationBeanPostProcessor并没有实现SmartInstantiationAwareBeanPostProcessor，也就是在获取早期对象这一阶段，并不会调AsyncAnnotationBeanPostProcessor处理@Async注解。
为什么@Async注解遇上循环依赖，Spring无法解决？
这里我们就拿前面的例子来说，AService加了@Async注解，AService先创建，发现引用了BService，那么BService就会去创建，当Service创建的过程中发现引用了AService，那么就会通过AnnotationAwareAspectJAutoProxyCreator 这个类实现的 getEarlyBeanReference 方法获取AService的早期引用对象，此时这个早期引用对象可能会被代理，取决于AService是否需要被代理，但是一定不是处理@Async注解的代理，原因前面也说过。
于是BService创建好之后，注入给了AService，那么AService会继续往下处理，前面说过，当初始化阶段完成之后，会调用所有的BeanPostProcessor的实现的 postProcessAfterInitialization 方法。于是就会回调依次回调 AnnotationAwareAspectJAutoProxyCreator 和 AsyncAnnotationBeanPostProcessor 的 postProcessAfterInitialization 方法实现。
这段回调有两个细节：
AnnotationAwareAspectJAutoProxyCreator回调：会发现AService对象已经被早期引用了，什么都不处理，直接把对象AService给返回
AsyncAnnotationBeanPostProcessor回调：发现AService类中加了@Async注解，那么就会对AnnotationAwareAspectJAutoProxyCreator返回的对象进行动态代理，然后返回了动态代理对象。
这段回调完，是不是已经发现了问题。早期暴露出去的对象，可能是AService本身或者是AService的代理对象，而且是通过AnnotationAwareAspectJAutoProxyCreator对象实现的，但是通过AsyncAnnotationBeanPostProcessor的回调，会对AService对象进行动态代理，这就导致AService早期暴露出去的对象跟最后完全创造出来的对象不是同一个，那么肯定就不对了。
同一个Bean在一个Spring中怎么能存在两个不同的对象呢，于是就会抛出BeanCurrentlyInCreationException异常，这段判断逻辑的代码如下：
if (earlySingletonExposure) {
// 获取到早期暴露出去的对象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
// 早期暴露的对象不为null，说明出现了循环依赖
if (exposedObject == bean) {
// 这个判断的意思就是指 postProcessAfterInitialization 回调没有进行动态代理，如果没有那么就将早期暴露出去的对象赋值给最终暴露（生成）出去的对象，
// 这样就实现了早期暴露出去的对象和最终生成的对象是同一个了
// 但是一旦 postProcessAfterInitialization 回调生成了动态代理 ，那么就不会走这，也就是加了@Aysnc注解，是不会走这的
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// allowRawInjectionDespiteWrapping 默认是false
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
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.");
}
}
}
}Salin selepas log masuk
所以，之所以@Async注解遇上循环依赖，Spring无法解决，是因为@Aysnc注解会使得最终创建出来的Bean，跟早期暴露出去的Bean不是同一个对象，所以就会报错。
出现循环依赖异常之后如何解决？
解决这个问题的方法很多
1、调整对象间的依赖关系，从根本上杜绝循环依赖，没有循环依赖，就没有早期暴露这么一说，那么就不会出现问题
2、不使用@Async注解，可以自己通过线程池实现异步，这样没有@Async注解，就不会在最后生成代理对象，导致早期暴露的出去的对象不一样
3、可以在循环依赖注入的字段上加@Lazy注解
@Component
public class AService {
@Resource
@Lazy
private BService bService;
@Async
public void save() {
}
}Salin selepas log masuk
4、从上面的那段判断抛异常的源码注释可以看出，当allowRawInjectionDespiteWrapping为true的时候，就不会走那个else if，也就不会抛出异常，所以可以通过将allowRawInjectionDespiteWrapping设置成true来解决报错的问题，代码如下:
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
((DefaultListableBeanFactory) beanFactory).setAllowRawInjectionDespiteWrapping(true);
}
}Salin selepas log masuk
虽然这样设置能解决报错的问题，但是并不推荐，因为这样设置就允许早期注入的对象和最终创建出来的对象是不一样，并且可能会导致最终生成的对象没有被动态代理。
Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan masalah menggunakan anotasi @Async dalam projek but spring. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
