使用@Async异步注解导致该Bean在循环依赖时启动报BeanCurrentlyInCreationException异常的根本原因分析，以及提供解决方案【享学Spring】（中）

// @since 3.2   注意：@EnableAsync在Spring3.1后出现
// 继承自ProxyProcessorSupport，所以具有动态代理相关属性~ 方便创建代理对象
public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor {
  // 这里会缓存所有被处理的Bean~~~  eligible：合适的
  private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<>(256);
  //postProcessBeforeInitialization方法什么不做~
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) {
    return bean;
  }
  // 关键是这里。当Bean初始化完成后这里会执行，这里会决策看看要不要对此Bean创建代理对象再返回~~~
  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (this.advisor == null || bean instanceof AopInfrastructureBean) {
      // Ignore AOP infrastructure such as scoped proxies.
      return bean;
    }
    // 如果此Bean已经被代理了（比如已经被事务那边给代理了~~）
    if (bean instanceof Advised) {
      Advised advised = (Advised) bean;
      // 此处拿的是AopUtils.getTargetClass(bean)目标对象，做最终的判断
      // isEligible()是否合适的判断方法  是本文最重要的一个方法，下文解释~
      // 此处还有个小细节：isFrozen为false也就是还没被冻结的时候，就只向里面添加一个切面接口   并不要自己再创建代理对象了  省事
      if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
        // Add our local Advisor to the existing proxy's Advisor chain...
        // beforeExistingAdvisors决定这该advisor最先执行还是最后执行
        // 此处的advisor为：AsyncAnnotationAdvisor  它切入Class和Method标注有@Aysnc注解的地方~~~
        if (this.beforeExistingAdvisors) {
          advised.addAdvisor(0, this.advisor);
        } else {
          advised.addAdvisor(this.advisor);
        }
        return bean;
      }
    }
    // 若不是代理对象，此处就要下手了~~~~isEligible() 这个方法特别重要
    if (isEligible(bean, beanName)) {
      // copy属性  proxyFactory.copyFrom(this); 生成一个新的ProxyFactory 
      ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
      // 如果没有强制采用CGLIB 去探测它的接口~
      if (!proxyFactory.isProxyTargetClass()) {
        evaluateProxyInterfaces(bean.getClass(), proxyFactory);
      }
      // 添加进此切面~~ 最终为它创建一个getProxy 代理对象
      proxyFactory.addAdvisor(this.advisor);
      //customize交给子类复写（实际子类目前都没有复写~）
      customizeProxyFactory(proxyFactory);
      return proxyFactory.getProxy(getProxyClassLoader());
    }
    // No proxy needed.
    return bean;
  }
  // 我们发现BeanName最终其实是没有用到的~~~
  // 但是子类AbstractBeanFactoryAwareAdvisingPostProcessor是用到了的  没有做什么 可以忽略~~~
  protected boolean isEligible(Object bean, String beanName) {
    return isEligible(bean.getClass());
  }
  protected boolean isEligible(Class<?> targetClass) {
    // 首次进来eligible的值肯定为null~~~
    Boolean eligible = this.eligibleBeans.get(targetClass);
    if (eligible != null) {
      return eligible;
    }
    // 如果根本就没有配置advisor  也就不用看了~
    if (this.advisor == null) {
      return false;
    }
    // 最关键的就是canApply这个方法，如果AsyncAnnotationAdvisor  能切进它  那这里就是true
    // 本例中方法标注有@Aysnc注解，所以铁定是能被切入的  返回true继续上面方法体的内容
    eligible = AopUtils.canApply(this.advisor, targetClass);
    this.eligibleBeans.put(targetClass, eligible);
    return eligible;
  }
  ...
}

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowRawInjectionDespiteWrapping(true);
    }
}

@Service
public class B implements BInterface {
    @Lazy
    @Autowired
    private AInterface a;
    @Override
    public void funB() {
        System.out.println("线程名称：" + Thread.currentThread().getName());
        a.funA();
    }
}