先对UserService的test方法进行切面，然后再对test方法进行@Async，在存在循环依赖的情况下，启动项目会报错
@Service
public class OrderService {
@Autowired
private UserService userService;
}
@Service
public class UserService {
@Autowired
private OrderService orderService;
@Async
public void test(){
System.out.println("test");
}
}
@ComponentScan(basePackages = "com.test.zh")
@EnableAspectJAutoProxy
@EnableAsync
public class SpringConfig {
}
@Aspect
@Component
public class TestAspect {
@Pointcut("execution(* com.test.zh.*..*(..))")
public void log(){
}
@Before("log()")
public void test(JoinPoint joinPoint) {
System.out.println("before aspect");
}
}
//AbstractAutowireCapableBeanFactory
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
Object exposedObject = bean;
try {
//依赖注入，循环依赖发生在这里，如果有循环依赖，则提前进行AOP
//并将代理对象放入二级缓存
this.populateBean(beanName, mbd, instanceWrapper);
//在这里进行初始化后的操作，如果已经进行过切面代理，则直接将原对象返回
//但是方法如果被@Async修饰，则会直接创建代理对象，并将代理对象返回，所以这里返回的是代理对象，导致后面exposedObject != bean
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
//如果已经进行过AOP，则从二级缓存中将代理对象返回
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
//AbstractAutowireCapableBeanFactory
@Override
//依次进行初始化后操作
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//先进行AspectJ的切面操作，AspectJ的切面操作，如果发现已经执行过代理，则将原对象返回
//然后进行Async的切面操作，这里不会判断原对象是否经过代理，而是直接生成代理对象，将代理对象返回
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
//AbstractAutoProxyCreator#postProcessAfterInitialization
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//如果已经进行过AOP，则直接将原对象返回
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
原因总结
当被方法被@Async修饰，这个类会被代理，而且会直接生成代理对象，导致在doCreateBean中，判断的时候，exposedObject和bean不再相等。
解决办法
发生循环依赖的依赖注入上，加上@Lazy
@Service
public class UserService {
@Autowired
@Lazy
private OrderService orderService;
@Async
public void test(){
System.out.println(orderService);
}
}
原理
当在依赖注入上加上@Lazy时，注入这个属性时，就不会去容器中查找对象是否存在，而是直接生成这个属性的代理对象。直到调用test方法时，打印orderService需要调用OrderService的toString方法，此时才会去容器中查找是否有orderService的普通对象，如果沒有，则进行创建。但是此时UserService对象已经创建好了，放入单例池中了，所以就不存在循环依赖了，创建OrderService对象时，UserService对象可以直接注入。
