你必须知道的SpringAsync的一些坑

　　前言
　　大家都知道 用@Trancational，@Async，@Retryable 等注解时，需要用代理调用才生效，用this调用是不生效的。
　　大多数情况，是由另外的类发起调用，这是没有问题的。
　　少数情况下，存在本类调用本类方法，这种情况下要做到注解生效，该怎么办呢？
　　常见的解决方法有以下几种： 从applicationContext种获取bean 自己注入自己 AopContext.currentProxy() 需要使用 @EnableAspectJAutoProxy(exposeProxy = true)@Async注解的原理
　　@EnableAsync注解上标注了@Import(AsyncConfigurationSelector.class)，AsyncConfigurationSelector在默认情况下，会选择出来ProxyAsyncConfiguration类进行导入，即把ProxyAsyncConfiguration类作为@Configuration类配置到ApplicationContext @Configuration @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {      @Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)    public AsyncAnnotationBeanPostProcessor asyncAdvisor() {       Assert.notNull(this.enableAsync, ＂@EnableAsync annotation metadata was not injected＂);       AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();       Class<? extends Annotation> customAsyncAnnotation = this.enableAsync.getClass(＂annotation＂);       if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, ＂annotation＂)) {          bpp.setAsyncAnnotationType(customAsyncAnnotation);       }       if (this.executor != null) {          bpp.setExecutor(this.executor);       }       if (this.exceptionHandler != null) {          bpp.setExceptionHandler(this.exceptionHandler);       }       bpp.setProxyTargetClass(this.enableAsync.getBoolean(＂proxyTargetClass＂));       bpp.setOrder(this.enableAsync.getNumber(＂order＂));       return bpp;    }   }
　　这段代码的作用是把AsyncAnnotationBeanPostProcessor作为Bean注册到Context中。
　　我们看下这个Async相关的BPP做了什么操作： // 潜质处理不做任何动作，可保证在调用bean的init之前，bean本身没有任何变化。 @Override public Object postProcessBeforeInitialization(Object bean, String beanName) {     return bean; }   @Override public Object postProcessAfterInitialization(Object bean, String beanName) {     // 如果是AOP相关的基础组件bean，如ProxyProcessorSupport类及其子类，则直接返回。     if (bean instanceof AopInfrastructureBean) {         // Ignore AOP infrastructure such as scoped proxies.         return bean;     }       if (bean instanceof Advised) {         // 如果已经是Advised的，即已经是被动态代理的实例，则直接添加advisor。         Advised advised = (Advised) bean;         if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {             // 如果没有被frozen(即冷冻，不再做改动的动态代理实例)且是Eligbile(合适的)，则把其添加到advisor中。根据配置决定插入位置。             // 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)) {         // 如果是Eligible合适的，且还不是被代理的类，则创建一个代理类的实例并返回。         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; } // 准备ProxyFactory对象 protected ProxyFactory prepareProxyFactory(Object bean, String beanName) {     ProxyFactory proxyFactory = new ProxyFactory();     proxyFactory.copyFrom(this);     // 设置被代理的bean为target，这个bean是真实的bean。     proxyFactory.setTarget(bean);     return proxyFactory; }
　　Spring在对一个类进行AOP代理后，会为此类加上Advised接口，返回的动态代理对象都会带上Advised接口修饰，那么第一段逻辑判断bean instanceof Advised的目的就是判断是否已经是被动态代理的类，如果是，则为其添加一个Advisor增强器。
　　如果不是动态代理的对象，因为@Async要为方法增加代理，并转换为异步执行，故需要把原始bean转换为被AOP动态代理的bean。 快问快答
　　问题1：@Async注解在使用第三种方法AopContext.currentProxy() 调用本类方法能生效吗？
　　答案：不能生效
　　原因：EnableAspectJAutoProxy(exposeProxy=true)用的是  AnnotationAwareAspectJAutoProxyCreator 这个bbp 所以EnableAspectJAutoProxy(exposeProxy=true) 这个注解的 exposeProxy=true 只针对由这个bbp创建的代理类生效，而Async注解的代理是由自己创建的
　　问题2：@Transactional注解在使用第三种方法AopContext.currentProxy() 调用本类方法能生效吗？
　　答案：可以生效
　　原因：Transactional注解种的bbp是 InfrastructureAdvisorAutoProxyCreator，而 EnableAspectJAutoProxy 会把 InfrastructureAdvisorAutoProxyCreator 替换成 AnnotationAwareAspectJAutoProxyCreator。代码在  AopConfigUtils 种的 registerOrEscalateApcAsRequired  方法 /**  * Stores the auto proxy creator classes in escalation order.  */ private static final List> APC_PRIORITY_LIST = new ArrayList>();   /**  * Setup the escalation list.  */ static {    APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);    APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);    APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class); }        private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {    Assert.notNull(registry, ＂BeanDefinitionRegistry must not be null＂);    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {       BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);       if (!cls.getName().equals(apcDefinition.getBeanClassName())) {          int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());          int requiredPriority = findPriorityForClass(cls);          if (currentPriority < requiredPriority) {             apcDefinition.setBeanClassName(cls.getName());          }       }       return null;    }    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);    beanDefinition.setSource(source);    beanDefinition.getPropertyValues().add(＂order＂, Ordered.HIGHEST_PRECEDENCE);    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);    return beanDefinition; }
　　所以 Transactional注解是能享受到 EnableAspectJAutoProxy 注解的福利的
　　问题3：@Transactional @Async 一起用的话 调用本类方法能生效吗？
　　答案：可以生效
　　原因：AsyncAnnotationBeanPostProcessor 优先级是最低 而AnnotationAwareAspectJAutoProxyCreator 优先级是最高，所以Async注解可以不用自己创建代理，而复用AnnotationAwareAspectJAutoProxy创建的代理。
　　引申：为什么引入spring cloud starter sleuth包后 @Async注解就能用AopContext.currentProxy
　　原因：sleuth包中定义了 @Async的切面