【小家Spring】Spring AOP的核心类：AbstractAdvisorAutoProxy自动代理创建器深度剖析（AnnotationAwareAspectJAutoProxyCreator）（上）-阿里云开发者社区

前言

上篇博文：

【小家Spring】面向切面编程之—Spring AOP的原理讲解以及源码分析（Cannot find current proxy: Set ‘exposeProxy’ property on ）

已经刚刚结合实例，介绍了Spring AOP的过程以及对源码进行了逐步分析~

但是这中间当时事忽略了整个Spring AOP最为核心的一个类：自动代理创建器。

本文将主要以AnnotationAwareAspectJAutoProxyCreator为引线，好好聊聊自动代理创建器是做什么的，具体做了什么，以及Spring为我们提供的其它几个Creator：DefaultAdvisorAutoProxyCreator，InfrastructureAdvisorAutoProxyCreator和AspectJAwareAdvisorAutoProxyCreator，有何区别和对应的实用场景

可以看出来，所有的创建器都是AbstractAutoProxyCreator该抽象类的子类~

当系统比较复杂，或者中需要进行aop进行织入的bean较多时，简单采用ProxyFacotryBean无疑会增加很多工作量（因为每个Bean都得手动写一个）。另外由于要从ProxyFactoryBean获得代理对象，也会使应用和Spring之间的耦合度增加，并且很多时候可维护性不强（我个人认为耦合这个不是最主要的原因，毕竟现在Spring已成为实际上的规范了）。

譬如，我们需要给bean名字满足“*service”的bean每个方法增加事务功能，如果采用ProxyFacotryBean必须为每个以service结尾的bean增加一个配置（工作量巨大），若需要修改，这个后果是灾难性的。

这样的情况下，自动代理的方式就能发挥它巨大的优势了，牛刀小试一把，上面案例只需下面一个类就搞定了（这里以功能最弱的BeanNameAutoProxyCreator为例）：

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  <property name="beanNames"><value>*service</value></property>
  <property name="interceptorNames">
    <list>
      <!-- 这里可以写具体的Interceptor的BeanName -->
      <value>myInterceptor</value>
    </list>
  </property>
</bean>

Spring中自动创建代理器（分类）

在内部，Spring使用BeanPostProcessor让自动生成代理。基于BeanPostProcessor的自动代理创建器的实现类，将根据一些规则在容器实例化Bean时为匹配的Bean生成代理实例。代理创建器可以分为三类：

基于Bean配置名规则的自动代理生成器：允许为一组特定配置名的Bean自动创建代理实例的代理创建器，实现类为BeanNameAutoProxyCreator
基于Advisor匹配机制的自动代理创建器它会对容器中的所有Advisor进行扫描，自动将这些切面应用到匹配的Bean中，实现类是DefaultAdvisorAutoProxyCreator（它也支持前缀匹配）
基于Bean中AspectJ注解的自动代理生成器：为包含AspectJ注解的切入的Bean自动创建代理实例

AbstractAutoProxyCreator

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
    implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    ...
}

首先它继承自：ProxyProcessorSupport：这个类应该很熟了，我们之前介绍过的三大创建代理对象的工厂ProxyFactoryBean、ProxyFactory、AspectJProxyFactory都是继承自此类的

参考：【小家Spring】面向切面编程Spring AOP创建代理的方式：ProxyFactoryBean、ProxyFactory、AspectJProxyFactory（JDK Proxy和CGLIB）

这里还是简单的科普一下吧：

// 显然，它是个ProxyConfig 拥有AOP的基本配置
public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {
  ...
  // 这是它最重要的一个方法：就是把该bean所有的实现的接口 都作用在ProxyFactory 上 当然是有过滤得
  protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
    // 拿到该类所有实现的接口们~~~~
    Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
    // 标记：是否存在“有问题的”代理接口  默认是false
    boolean hasReasonableProxyInterface = false;
    for (Class<?> ifc : targetInterfaces) {
      //判断这些接口是否是“有问题的”：既我们需要处理的
      if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
          ifc.getMethods().length > 0) {
        hasReasonableProxyInterface = true;
        break;
      }
    }
    // 说明除开哪些接口外，但凡有一个有用的接口，就add进去（这样就会采用JDK的动态代理了）
    if (hasReasonableProxyInterface) {
      for (Class<?> ifc : targetInterfaces) {
        proxyFactory.addInterface(ifc);
      }
    }
    // 否则直接采用CGLIB
    else {
      proxyFactory.setProxyTargetClass(true);
    }
  }
  // InitializingBean...Aware接口的子接口等等这些回调性质的接口
  protected boolean isConfigurationCallbackInterface(Class<?> ifc) {
    return (InitializingBean.class == ifc || DisposableBean.class == ifc || Closeable.class == ifc ||
        AutoCloseable.class == ifc || ObjectUtils.containsElement(ifc.getInterfaces(), Aware.class));
  }
  // 接口名称为这些的  也就是spring aop自己的东西
  protected boolean isInternalLanguageInterface(Class<?> ifc) {
    return (ifc.getName().equals("groovy.lang.GroovyObject") ||
        ifc.getName().endsWith(".cglib.proxy.Factory") ||
        ifc.getName().endsWith(".bytebuddy.MockAccess"));
  }
}

AbstractAutoProxyCreator是对自动代理创建器的一个抽象实现。最重要的是，它实现了SmartInstantiationAwareBeanPostProcessor接口，因此会介入到Spring IoC容器Bean实例化的过程，因此由此为入口进行展开~

SmartInstantiationAwareBeanPostProcessor继承自InstantiationAwareBeanPostProcessor继承自BeanPostProcessor 所以它需要实现的方法有很多~~~

这里重点提一个方法(如下图)：在bean被crate之前，先会执行所有的InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation，谁第一个返回了不为null的Bean，后面就都不会执行了。然后会再执行BeanPostProcessor#postProcessAfterInitialization 就完事了

按照执行顺序，我们来看看AbstractAutoProxyCreator的实现：

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
    implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
  // 实现类就是我们熟悉的它： DefaultAdvisorAdapterRegistry
  private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance(); 
  // 目标源的创建器。它有一个方法getTargetSource(Class<?> beanClass, String beanName)
  // 两个实现类：QuickTargetSourceCreator和LazyInitTargetSourceCreator
  // 它的具体使用 后面有详解
  @Nullable
  private TargetSourceCreator[] customTargetSourceCreators;
  @Nullable
  private BeanFactory beanFactory;
  ...
  private final Set<String> targetSourcedBeans = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
  private final Set<Object> earlyProxyReferences = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
  private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<>(16);
  private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);
  ...
  // 可以自己指定Registry 
  public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) {
    this.advisorAdapterRegistry = advisorAdapterRegistry;
  }
  // 可议指定多个
  public void setCustomTargetSourceCreators(TargetSourceCreator... targetSourceCreators) {
    this.customTargetSourceCreators = targetSourceCreators;
  }
  // 通用拦截器得名字。These must be bean names in the current factory
  // 这些Bean必须在当前容器内存在的~~~
  public void setInterceptorNames(String... interceptorNames) {
    this.interceptorNames = interceptorNames;
  }
  //Set whether the common interceptors should be applied before bean-specific ones
  // 默认值是true
  public void setApplyCommonInterceptorsFirst(boolean applyCommonInterceptorsFirst) {
    this.applyCommonInterceptorsFirst = applyCommonInterceptorsFirst;
  }
  //===========下面是关于BeanPostProcessor的一些实现方法============
  // getBeanNamesForType()的时候会根据每个BeanName去匹配类型合适的Bean，这里不例外，也会帮忙在proxyTypes找一下
  @Override
  @Nullable
  public Class<?> predictBeanType(Class<?> beanClass, String beanName) {
    if (this.proxyTypes.isEmpty()) {
      return null;
    }
    Object cacheKey = getCacheKey(beanClass, beanName);
    return this.proxyTypes.get(cacheKey);
  }
  // getEarlyBeanReference()它是为了解决单例bean之间的循环依赖问题，提前将代理对象暴露出去
  @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);
  }
  // 不做构造函数检测，返回null 让用空构造初始化吧
  @Override
  @Nullable
  public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
    return null;
  }
  // 这个很重要，在Bean实例化之前，先给一个机会，看看缓存里有木有，有就直接返回得了
  // 简单的说：其主要目的在于如果用户使用了自定义的TargetSource对象，则直接使用该对象生成目标对象，而不会使用Spring的默认逻辑生成目标对象
  // (并且这里会判断各个切面逻辑是否可以应用到当前bean上)
  @Override
  public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    Object cacheKey = getCacheKey(beanClass, beanName);
    // beanName无效或者targetSourcedBeans里不包含此Bean
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
      //advisedBeans：已经被通知了的（被代理了的）Bean~~~~  如果在这里面  也返回null 
      if (this.advisedBeans.containsKey(cacheKey)) {
        return null;
      }
      // isInfrastructureClass:Advice、Pointcut、Advisor、AopInfrastructureBean的子类，表示是框架所属的Bean
      // shouldSkip:默认都是返回false的。AspectJAwareAdvisorAutoProxyCreator重写此方法：只要存在一个Advisor   ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)成立  就返回true
      if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {  
        // 所以这里会把我们所有的Advice、Pointcut、Advisor、AopInfrastructureBean等Bean都装进来
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return null;
      }
    }
    //到这，只有在TargetSource中没有进行缓存，并且应该被切面逻辑环绕，但是目前还未生成代理对象的bean才会通过此方法
    // Create proxy here if we have a custom TargetSource.
    // 如果我们有TargetSourceCreator，这里就会创建一个代理对象
    // getCustomTargetSource逻辑：存在TargetSourceCreator  并且 beanFactory.containsBean(beanName)  然后遍历所有的TargetSourceCreator，调用getTargetSource谁先创建不为null就终止
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    // 若创建好了这个代理对象，继续进一步的操作：：：
    if (targetSource != null) {
      if (StringUtils.hasLength(beanName)) {
          // 缓存起来
        this.targetSourcedBeans.add(beanName);
      }
      //getAdvicesAndAdvisorsForBean：方法判断当前bean是否需要进行代理，若需要则返回满足条件的Advice或者Advisor集合
      // 这个方法由子类实现，AbstractAdvisorAutoProxyCreator和BeanNameAutoProxyCreator  代表中两种不同的代理方式
      Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
      // 顾名思义，就是根据目标对象创建代理对象的核心逻辑了 下面详解
      Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
      // 把创建好的代理  缓存~~~
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
    }
    return null;
  }
  // 这个方法也很重要，若我们自己要实现一个TargetSourceCreator ，就可议实现我们自定义的逻辑了
  // 这里条件苛刻：customTargetSourceCreators 必须不为null
  // 并且容器内还必须有这个Bean：beanFactory.containsBean(beanName)    备注：此BeanName指的即将需要被代理得BeanName，而不是TargetSourceCreator 的BeanName
  //下面会介绍我们自己自定义一个TargetSourceCreator 来实现我们自己的逻辑
  @Nullable
  protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) {
    // We can't create fancy target sources for directly registered singletons.
    if (this.customTargetSourceCreators != null &&
        this.beanFactory != null && this.beanFactory.containsBean(beanName)) {
      for (TargetSourceCreator tsc : this.customTargetSourceCreators) {
        TargetSource ts = tsc.getTargetSource(beanClass, beanName);
        if (ts != null) {
          // Found a matching TargetSource.
          if (logger.isDebugEnabled()) {
            logger.debug("TargetSourceCreator [" + tsc +
                " found custom TargetSource for bean with name '" + beanName + "'");
          }
          return ts;
        }
      }
    }
    // No custom TargetSource found.
    return null;
  }
  // 这三个方法，没做什么动作~~
  @Override
  public boolean postProcessAfterInstantiation(Object bean, String beanName) {
    return true;
  }
  @Override
  public PropertyValues postProcessPropertyValues(
      PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
    return pvs;
  }
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) {
    return bean;
  }
  // 代理是通过AbstractAutoProxyCreator中的postProcessAfterInitialization()创建的
  // 因此这个方法是蛮重要的，主要是wrapIfNecessary()方法会特别的重要
  // earlyProxyReferences缓存：该缓存用于保存已经创建过代理对象的cachekey，**避免重复创建**
  @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;
  }
  // ============wrapIfNecessary方法==============
  protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 若此Bean已经在targetSourcedBeans里，说明已经被代理过，那就直接返回即可
    // (postProcessBeforeInstantiation()中成功创建的代理对象都会将beanName加入到targetSourceBeans中)
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
      return bean;
    }
    // 如果该Bean基础框架Bean或者免代理得Bean，那也不处理
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
      return bean;
    }
    // 逻辑同上，对于实现了Advice，Advisor，AopInfrastructureBean接口的bean，都认为是spring aop的基础框架类，不能对他们创建代理对象，
    // 同时子类也可以覆盖shouldSkip方法来指定不对哪些bean进行代理
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
      this.advisedBeans.put(cacheKey, Boolean.FALSE);
      return bean;
    }
    // Create proxy if we have advice.
    // getAdvicesAndAdvisorsForBean该方法由子类实现，如国有Advice切面切进去了，我们就要给他代理
    //根据getAdvicesAndAdvisorsForBean()方法的具体实现的不同，AbstractAutoProxyCreator又分成了两类自动代理机制
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    // 需要代理，那就进来给它创建一个代理对象吧
    if (specificInterceptors != DO_NOT_PROXY) {
      // 缓存起来，赋值为true，说明此key是被代理了的
      this.advisedBeans.put(cacheKey, Boolean.TRUE);
      // 创建这个代理对象
      Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
      // 创建好后缓存起来  避免重复创建
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
    }
    // 不需要代理，也把这种不需要代理的对象给与缓存起来  赋值为false
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
  }
  // 创建代理对象  specificInterceptors：作用在这个Bean上的增强器们
  // 这里需要注意的地方：入参是targetSource  而不是target
  // 所以最终代理的是  ``每次AOP代理处理方法调用时，目标实例都会用到TargetSource实现``
  protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
      @Nullable Object[] specificInterceptors, TargetSource targetSource) {
    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
      AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }
    // 这个我们非常熟悉了ProxyFactory   创建代理对象的三大方式之一~~~
    ProxyFactory proxyFactory = new ProxyFactory();
    // 复制当前类的相关配置，因为当前类它也是个ProxyConfig
    proxyFactory.copyFrom(this);
    // 看看是否是基于类的代理（CGLIB），若表面上是基于接口的代理  我们还需要进一步去检测
    if (!proxyFactory.isProxyTargetClass()) {
      // shouldProxyTargetClass方法用于判断是否应该使用targetClass类而不是接口来进行代理
      // 默认实现为和该bean定义是否属性值preserveTargetClass为true有关。默认情况下都不会有此属性值的~~~~~
      if (shouldProxyTargetClass(beanClass, beanName)) {
        proxyFactory.setProxyTargetClass(true);
      }
      // 到此处，上面说了，就是把这个类实现的接口们，都放进proxyFactory（当然也会处理一些特殊的接口~~~不算数的）
      else {
        evaluateProxyInterfaces(beanClass, proxyFactory);
      }
    }
    // buildAdvisors：整理合并得到最终的advisors （毕竟interceptorNames还指定了一些拦截器的）
    // 至于调用的先后顺序，通过applyCommonInterceptorsFirst参数可以进行设置，若applyCommonInterceptorsFirst为true，interceptorNames属性指定的Advisor优先调用。默认为true
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    // 添加进工厂里
    proxyFactory.addAdvisors(advisors);
    // 把targetSource放进去  TargetSource的实现方式有多种 后面会介绍
    proxyFactory.setTargetSource(targetSource);
    // 这个方法是交给子类的，子类可以继续去定制此proxyFactory（Spring内部并没有搭理它）
    customizeProxyFactory(proxyFactory);
    // 沿用this得freezeProxy的属性值
    proxyFactory.setFrozen(this.freezeProxy);
    // 设置preFiltered的属性值，默认是false。子类：AbstractAdvisorAutoProxyCreator修改为true
    // preFiltered：字段意思为：是否已为特定目标类筛选Advisor
    // 这个字段和DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice获取所有的Advisor有关
    //CglibAopProxy和JdkDynamicAopProxy都会调用此方法，然后递归执行所有的Advisor的
    if (advisorsPreFiltered()) {
      proxyFactory.setPreFiltered(true);
    }
    // getProxyClassLoader():调用者可议指定  否则为：ClassUtils.getDefaultClassLoader()
    return proxyFactory.getProxy(getProxyClassLoader());
  }
  // 下面，只剩一个重要的方法：buildAdvisors()没有解释了
  protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {
    // 解析interceptorNames而来得Advisor数组~~~
    Advisor[] commonInterceptors = resolveInterceptorNames();
    // 注意：此处用得事Object
    List<Object> allInterceptors = new ArrayList<>();
    if (specificInterceptors != null) {
      allInterceptors.addAll(Arrays.asList(specificInterceptors));
      // 若解析它来的有内容
      if (commonInterceptors.length > 0) {
        // 放在头部  也就是最上面
        if (this.applyCommonInterceptorsFirst) {
          allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
        }
        // 放在末尾
        else {
          allInterceptors.addAll(Arrays.asList(commonInterceptors));
        }
      }
    }
    // 把每一个Advisor都用advisorAdapterRegistry.wrap()包装一下~~~~
    // 注意wrap方法，默认只支持那三种类型的Advice转换为Advisor的~~~
    Advisor[] advisors = new Advisor[allInterceptors.size()];
    for (int i = 0; i < allInterceptors.size(); i++) {
      advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
    }
    return advisors;
  }
  // 处理interceptorNames，去容器内找出来
  private Advisor[] resolveInterceptorNames() {
    BeanFactory bf = this.beanFactory;
    ConfigurableBeanFactory cbf = (bf instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) bf : null);
    List<Advisor> advisors = new ArrayList<>();
    for (String beanName : this.interceptorNames) {
      // 排除一些情况：此工厂不是ConfigurableBeanFactory或者该Bean不在创建中
      if (cbf == null || !cbf.isCurrentlyInCreation(beanName)) {
        Assert.state(bf != null, "BeanFactory required for resolving interceptor names");
        // 拿到这个Bean，然后使用advisorAdapterRegistry把它适配一下即可~~~
        Object next = bf.getBean(beanName);
        advisors.add(this.advisorAdapterRegistry.wrap(next));
      }
    }
    return advisors.toArray(new Advisor[0]);
  }
}