/**
 * 切面类
 */
@Component
@EnableAspectJAutoProxy
@Aspect
public class AspectAdviceBeanUseAnnotation {
  // 定义一个全局的Pointcut
  @Pointcut("execution(* com.study.spring.sample.aop.*.do*(..))")
  public void doMethods() {
  }
  @Pointcut("execution(* com.study.spring.sample.aop.*.service*(..))")
  public void services() {
  }
  // 定义一个Before Advice
  @Before("doMethods() and args(tk,..)")
  public void before3(String tk) {
    System.out.println("----------- AspectAdviceBeanUseAnnotation before3  增强  参数tk= " + tk);
  }
  @Around("services() and args(name,..)")
  public Object around2(ProceedingJoinPoint pjp, String name) throws Throwable {
    System.out.println("--------- AspectAdviceBeanUseAnnotation arround2 参数 name=" + name);
    System.out.println("----------- AspectAdviceBeanUseAnnotation arround2 环绕-前增强 for " + pjp);
    Object ret = pjp.proceed();
    System.out.println("----------- AspectAdviceBeanUseAnnotation arround2 环绕-后增强 for " + pjp);
    return ret;
  }
  @AfterReturning(pointcut = "services()", returning = "retValue")
  public void afterReturning(Object retValue) {
    System.out.println("----------- AspectAdviceBeanUseAnnotation afterReturning 增强 , 返回值为： " + retValue);
  }
  @AfterThrowing(pointcut = "services()", throwing = "e")
  public void afterThrowing(JoinPoint jp, Exception e) {
    System.out.println("----------- AspectAdviceBeanUseAnnotation afterThrowing 增强  for " + jp);
    System.out.println("----------- AspectAdviceBeanUseAnnotation afterThrowing 增强  异常 ：" + e);
  }
  @After("doMethods()")
  public void after(JoinPoint jp) {
    System.out.println("----------- AspectAdviceBeanUseAnnotation after 增强  for " + jp);
  }
  /*
   * BeanDefinitionRegistryPostProcessor BeanFactoryPostProcessor
   * InstantiationAwareBeanPostProcessor Bean实例创建前后 BeanPostProcessor
   */
}
复制代码

@Component
public class BeanQ {
  public void do1(String task, int time) {
    System.out.println("-------------do1 do " + task + " time:" + time);
  }
  public String service1(String name) {
    System.out.println("-------------servce1 do " + name);
    return name;
  }
  public String service2(String name) {
    System.out.println("-------------servce2 do " + name);
    if (!"s1".equals(name)) {
      throw new IllegalArgumentException("参数 name ！= s1, name=" + name);
    }
    return name + " hello!";
  }
}
复制代码

@Configuration
@ComponentScan
public class AopMainAnno {
  public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(AopMainAnno.class);
    BeanQ bq = context.getBean(BeanQ.class);
    bq.do1("task1", 20);
    System.out.println();
    bq.service1("service1");
    System.out.println();
    bq.service2("s1");
  }
}
复制代码

public List<Advisor> findAdvisorBeans() {
    // Determine list of advisor bean names, if not cached already.
    String[] advisorNames = this.cachedAdvisorBeanNames;
    if (advisorNames == null) {
      // Do not initialize FactoryBeans here: We need to leave all regular beans
      // uninitialized to let the auto-proxy creator apply to them!
      // 获取当前BeanFactory中所有实现了Advisor接口的bean的名称
      advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
          this.beanFactory, Advisor.class, true, false);
      this.cachedAdvisorBeanNames = advisorNames;
    }
    if (advisorNames.length == 0) {
      return new ArrayList<>();
    }
    // 对获取到的实现Advisor接口的bean的名称进行遍历
    List<Advisor> advisors = new ArrayList<>();
    // 循环所有的beanName，找出对应的增强方法
    for (String name : advisorNames) {
      // isEligibleBean()是提供的一个hook方法，用于子类对Advisor进行过滤，这里默认返回值都是true
      if (isEligibleBean(name)) {
        // 如果当前bean还在创建过程中，则略过，其创建完成之后会为其判断是否需要织入切面逻辑
        if (this.beanFactory.isCurrentlyInCreation(name)) {
          if (logger.isTraceEnabled()) {
            logger.trace("Skipping currently created advisor '" + name + "'");
          }
        }
        else {
          try {
            // 将当前bean添加到结果中
            advisors.add(this.beanFactory.getBean(name, Advisor.class));
          }
          catch (BeanCreationException ex) {
            // 对获取过程中产生的异常进行封装
            Throwable rootCause = ex.getMostSpecificCause();
            if (rootCause instanceof BeanCurrentlyInCreationException) {
              BeanCreationException bce = (BeanCreationException) rootCause;
              String bceBeanName = bce.getBeanName();
              if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
                if (logger.isTraceEnabled()) {
                  logger.trace("Skipping advisor '" + name +
                      "' with dependency on currently created bean: " + ex.getMessage());
                }
                // Ignore: indicates a reference back to the bean we're trying to advise.
                // We want to find advisors other than the currently created bean itself.
                continue;
              }
            }
            throw ex;
          }
        }
      }
    }
    return advisors;
  }
复制代码

/**
   * 真正的创建代理，判断一些列条件，有自定义的接口的就会创建jdk代理，否则就是cglib
   * @param config the AOP configuration in the form of an
   * AdvisedSupport object
   * @return
   * @throws AopConfigException
   */
  @Override
  public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    // 这段代码用来判断选择哪种创建代理对象的方式
    // config.isOptimize()   是否对代理类的生成使用策略优化 其作用是和isProxyTargetClass是一样的 默认为false
    // config.isProxyTargetClass() 是否使用Cglib的方式创建代理对象 默认为false
    // hasNoUserSuppliedProxyInterfaces目标类是否有接口存在 且只有一个接口的时候接口类型不是SpringProxy类型
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
      // 上面的三个方法有一个为true的话，则进入到这里
      // 从AdvisedSupport中获取目标类 类对象
      Class<?> targetClass = config.getTargetClass();
      if (targetClass == null) {
        throw new AopConfigException("TargetSource cannot determine target class: " +
            "Either an interface or a target is required for proxy creation.");
      }
      // 判断目标类是否是接口 如果目标类是接口的话，则还是使用JDK的方式生成代理对象
      // 如果目标类是Proxy类型 则还是使用JDK的方式生成代理对象
      if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
        return new JdkDynamicAopProxy(config);
      }
      // 配置了使用Cglib进行动态代理或者目标类没有接口,那么使用Cglib的方式创建代理对象
      return new ObjenesisCglibAopProxy(config);
    }
    else {
      // 使用JDK的提供的代理方式生成代理对象
      return new JdkDynamicAopProxy(config);
    }
  }
复制代码

public class ProxyConfig implements Serializable {
  /** use serialVersionUID from Spring 1.2 for interoperability. */
  private static final long serialVersionUID = -8409359707199703185L;
  // 是否代理的对象是类，动态代理分为代理接口和类，这里的属性默认是代理的接口
  private boolean proxyTargetClass = false;
  // 是否进行主动优化，默认是不会主动优化
  private boolean optimize = false;
  // 是否由此配置创建的代理不能被转成Advised类型，默认时候可转
  boolean opaque = false;
  // 是否会暴露代理在调用的时候，默认是不会暴露
  boolean exposeProxy = false;
  // 是否冻结此配置，不能被修改
  private boolean frozen = false;
}
复制代码