【小家Spring】Spring AOP的核心类：AbstractAdvisorAutoProxy自动代理创建器深度剖析（AnnotationAwareAspectJAutoProxyCreator）（中）

<!-- 这个我们也可以自己实现，也可以用Spring为我们提供好的 -->
<bean id="poolTargetSource"    
    class="org.springframework.aop.target.CommonsPoolTargetSource">  
    <property name="targetBeanName"><value>businessObject</value></property>  
    <property name="maxSize"><value>25</value></property>  
</bean>  
<!-- 让具体的Bean代理，去使用我们自己指定的targetSource(一般只有非单例的需要自己去实现) -->
<bean id="businessObject"   class="org.springframework.aop.framework.ProxyFactoryBean">  
    <property name="targetSource"><ref local="poolTargetSource"/></property>  
    <property name="interceptorNames"><value>myInterceptor</value></property>  
</bean>  

// 它是根据BeanName强相关的，所以现在和Spring容器是强关联的
@FunctionalInterface
public interface TargetSourceCreator {
  @Nullable
  TargetSource getTargetSource(Class<?> beanClass, String beanName);
}

public class QuickTargetSourceCreator extends AbstractBeanFactoryBasedTargetSourceCreator {
  // 可以看出，它的分类事根据BeanName以xxx开头来分辨的~~~这是一种约束
  public static final String PREFIX_COMMONS_POOL = ":";
  public static final String PREFIX_THREAD_LOCAL = "%";
  public static final String PREFIX_PROTOTYPE = "!";
  @Override
  @Nullable
  protected final AbstractBeanFactoryBasedTargetSource createBeanFactoryBasedTargetSource(
      Class<?> beanClass, String beanName) {
    if (beanName.startsWith(PREFIX_COMMONS_POOL)) {
      CommonsPool2TargetSource cpts = new CommonsPool2TargetSource();
      cpts.setMaxSize(25);
      return cpts;
    }
    else if (beanName.startsWith(PREFIX_THREAD_LOCAL)) {
      return new ThreadLocalTargetSource();
    }
    else if (beanName.startsWith(PREFIX_PROTOTYPE)) {
      return new PrototypeTargetSource();
    }
    else {
      // No match. Don't create a custom target source.
      return null;
    }
  }
}

@Order(Ordered.HIGHEST_PRECEDENCE) //我们希望自己定义的Bean最先被加载  所以这里优先级调到最高了 覆盖@EnableAspectJAutoProxy它自动导入的Bean
@Configuration
public class RootConfig {
    // 这里需要考虑到的是Spring对配置文件的加载顺序（@Import的解析顺序），我们必须在@EnableAspectJAutoProxy这个注解之前生效才有效
    // 同一个Configuration内解析顺序为：Process any @ComponentScan annotations ...  Process any @Import annotations  ... Process individual @Bean methods
    // 所以问题就在这里：如果我们把`@EnableAspectJAutoProxy`注解下载@Component这种Lite配置上，肯定会被先扫描进行的  所以这里：我极力不推荐这么做，而是放在Configuration正规的配置文件里
    // 然后又因为同一个@Import早于@Bean之前执行，所以我们必须放在不同的@Configaration文件内，然后通过控制配置类的顺序来达到目的~~~~（它支持@Order进行排序）
    // 参考链接：https://blog.csdn.net/f641385712/article/details/88554592 和  参考方法ConfigurationClassPostProcessor#processConfigBeanDefinitions
    @Bean(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME) //Bean名称务必只能是这个
    public AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator() {
        AnnotationAwareAspectJAutoProxyCreator creator = new AnnotationAwareAspectJAutoProxyCreator();
        // creator.setProxyTargetClass(true); 建议这里不要设置，还是取用注解的值来灵活控制最好了
        // 手动指定进去一个TargetSourceCreator(责任链模式：我们可以指定多个 ... )
        creator.setCustomTargetSourceCreators(new LazyInitTargetSourceCreator());
        return creator;
    }
}
@Order(Ordered.LOWEST_PRECEDENCE)
@EnableAspectJAutoProxy
@Configuration
public class AopConfig {
}

    @Bean
    public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
        BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
        // 给所有以serviceImpl结尾的类创建代理对象(支持正则)  备注：aliases也是被支持的
        // 注意此处若只写`*Service` 是匹配不上helloServiceImpl
        beanNameAutoProxyCreator.setBeanNames("*ServiceImpl");
        // 备注：它要想使用拦截，只能通过setInterceptorNames,从容器内拿Advice的实现类（自己书写）
        beanNameAutoProxyCreator.setInterceptorNames("myMethodInteceptor");
        return beanNameAutoProxyCreator;
    }

// 手动注册一个自动代理创建器，且名字务必叫AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME
@Bean(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME) 
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
  ...
}

//@since 10.10.2003  可以看出这个类出现得非常早
public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {
  @Nullable
  private List<String> beanNames;
  public void setBeanNames(String... beanNames) {
    Assert.notEmpty(beanNames, "'beanNames' must not be empty");
    this.beanNames = new ArrayList<>(beanNames.length);
    for (String mappedName : beanNames) {
      // 对mappedName做取出空白处理
      this.beanNames.add(StringUtils.trimWhitespace(mappedName));
    }
  }
  // simpleMatch并不是完整的正则。但是支持*这种通配符，其余的不支持哦
  protected boolean isMatch(String beanName, String mappedName) {
    return PatternMatchUtils.simpleMatch(mappedName, beanName);
  }
  // 这里面注意一点：BeanNameAutoProxyCreator的此方法并没有去寻找Advisor，所以需要拦截的话
  // 只能依靠：setInterceptorNames()来指定拦截器。它是根据名字去Bean容器里取的
  @Override
  @Nullable
  protected Object[] getAdvicesAndAdvisorsForBean(
      Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
    if (this.beanNames != null) {
      for (String mappedName : this.beanNames) {
        // 显然这里面，如果你针对的是FactoryBean,也是兼容的~~~
        if (FactoryBean.class.isAssignableFrom(beanClass)) {
          if (!mappedName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
            continue;
          }
          // 对BeanName进行处理，去除掉第一个字符
          mappedName = mappedName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
        }
        // 匹配就返回PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS 而不是再返回null了
        if (isMatch(beanName, mappedName)) {
          return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
        }
        // 这里需要注意的是，如国存在Bean工厂，哪怕任意一个alias匹配都是可以的~~~
        BeanFactory beanFactory = getBeanFactory();
        if (beanFactory != null) {
          String[] aliases = beanFactory.getAliases(beanName);
          for (String alias : aliases) {
            if (isMatch(alias, mappedName)) {
              return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
            }
          }
        }
      }
    }
    return DO_NOT_PROXY;
  }
}