注解@Async引发的Spring循环依赖分析

Posted on In ,

首先有一点可以确定，spring可以是解决某些循环依赖的，示例：

1
2
3
4
5
6
7
8
9
@Service
public class AService {

    @Autowired
    private BService bService;

    public void testA() {
    }
}
1
2
3
4
5
6
7
8
@Service
public class BService {
    @Autowired
    private AService aService;

    public void testB() {
    }
}

上面的例子，AService与BService存在循环依赖，运行也是没有问题的。现在开启异步(添加@EnableAsync），修改AService：

1
2
3
4
5
6
7
8
9
10
@Service
public class AService {

    @Autowired
    private BService bService;

    @Async
    public void testA() {
    }
}

再次运行，就有会有如下报错：

1
2
3
4
5
6
7
ERROR org.springframework.boot.SpringApplication - Application startup failed
org.springframework.beans.factory.BeanCurrentlyInCreationException: 
  Error creating bean with name 'AService': 
  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 bean. 
  This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.

要想了解原因，首先得分析下 @Aysnc 注解的Bean的创建代理的时机。@EnableAsync开启时会向容器注入AsyncAnnotationBeanPostProcessor，它是一个BeanPostProcessor，实现了postProcessAfterInitialization，具体的实现在其父类AbstractAdvisingBeanPostProcessor中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
	if (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 async proxy needed.
	return bean;
}

 
protected boolean isEligible(Object bean, String beanName) {
	return isEligible(bean.getClass());
}

protected boolean isEligible(Class<?> targetClass) {
	Boolean eligible = this.eligibleBeans.get(targetClass);
	if (eligible != null) {
		return eligible;
	}
	// 方法有 @Aysnc 注解，AopUtils.canApply 会判断为 true
	eligible = AopUtils.canApply(this.advisor, targetClass);
	this.eligibleBeans.put(targetClass, eligible);
	return eligible;
}

对 AService，AopUtils.canApply 返回 true，那么postProcessAfterInitialization就会返回一个proxy对象。

来看看示例异常错误的地方(AbstractAutowireCapableBeanFactory.class)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
		throws BeanCreationException {

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	//...略
	if (instanceWrapper == null) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	Object bean = instanceWrapper.getWrappedInstance();
	//...略

	// Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		//...略
		// 这里提前暴露
		addSingletonFactory(beanName, new ObjectFactory<Object>() {
			@Override
			public Object getObject() throws BeansException {
				return getEarlyBeanReference(beanName, mbd, bean);
			}
		});
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		populateBean(beanName, mbd, instanceWrapper);
		if (exposedObject != null) {
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
	}
	catch (Throwable ex) {
		//...略
	}

       // 这里报错了
	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<String>(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.");
				}
			}
		}
	}
 //...略
}

对AService，因为它支持提前暴露，因此会先加到缓存中addSingletonFactory；之后在populateBean方法中，由于依赖了BService，开始初始化BService，BService依赖AService，因此直接调用了getEarlyBeanReference得到了AService，此时BService获取到的是AService的原始类型引用。

之后AService继续执行到了initializeBean方法，会执行BeanPostProcessor，拿到的是一个代理对象，即exposedObject是一个代理对象，在后面判断的代码就返回了报错：

1
2
3
4
5
6
7
if (earlySingletonExposure) {
	Object earlySingletonReference = getSingleton(beanName, false);
	if (earlySingletonReference != null) {
		if (exposedObject == bean) {
			exposedObject = earlySingletonReference;
		}
		else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {

但是同样是注解，@Transactional却不会跟@Async有同样的问题，原因在于处理@Transactional注解的是InfrastructureAdvisorAutoProxyCreator，它是SmartInstantiationAwareBeanPostProcessor的子类，在getEarlyBeanReference方法中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
	Object exposedObject = bean;
	if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
				SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
				exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
				if (exposedObject == null) {
					return null;
				}
			}
		}
	}
	return exposedObject;
}

在SmartInstantiationAwareBeanPostProcessor中，复写了getEarlyBeanReference方法，暴露出去的就是代理对象：

1
2
3
4
5
6
7
8
@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);
}

之后postProcessAfterInitialization方法中，判断是否代理过，是的话，直接返回：

1
2
3
4
5
6
7
8
9
10
@Override
public Object postProcessAfterInitialization(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;
}

参考：
https://segmentfault.com/a/1190000021217176
https://cloud.tencent.com/developer/article/1497689
https://blog.csdn.net/f641385712/article/details/89430276
https://www.jb51.net/article/185794.htm