一. AOP切面源码分析

public List<Advisor> buildAspectJAdvisors() {
    /*
     * aspectNames: 用于保存切面名称的集合
     * aspectNames是缓存的类级别的切面, 缓存的是已经解析出来的切面信息
     */
    List<String> aspectNames = this.aspectBeanNames;

    // 如果aspectNames值为空, 那么就在第一个单例bean执行的时候调用后置处理器(AnnotationAwareAspectJAutoProxy)
    if (aspectNames == null) {
      // 加锁, 防止多个线程, 同时加载 Aspect
      synchronized (this) {
        aspectNames = this.aspectBeanNames;
        // 双重检查
        if (aspectNames == null) {
          // 保存所有从切面中解析出来的通知
          List<Advisor> advisors = new ArrayList<>();
          // 保存切面名称的集合
          aspectNames = new ArrayList<>();
          /*
           * 扫描Object的子类. 那就是扫描所有的类
           *
           * 这里传入要扫描的对象是Object.class. 也就是说去容器中扫描所有的类.
           * 循环遍历. 这个过程是非常耗性能的, 所以spring增加了缓存来保存切面
           *
           * 但事务功能除外, 事务模块是直接去容器中找到Advisor类型的类 选择范围小
           * spring 没有给事务模块加缓存
           */
          String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
              this.beanFactory, Object.class, true, false);

          // 循环遍历beanNames
          for (String beanName : beanNames) {
            if (!isEligibleBean(beanName)) {
              continue;
            }
            // We must be careful not to instantiate beans eagerly as in this case they
            // would be cached by the Spring container but would not have been weaved.
            // 通过beanName去容器中获取到对应class对象
            Class<?> beanType = this.beanFactory.getType(beanName);
            if (beanType == null) {
              continue;
            }
            // 判断bean是否是一个切面, 也就是脑袋上是否有@Aspect注解
            if (this.advisorFactory.isAspect(beanType)) {
              aspectNames.add(beanName);
              // 将beanName和class对象构建成一个AspectMetadata对象
              AspectMetadata amd = new AspectMetadata(beanType, beanName);
              if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                MetadataAwareAspectInstanceFactory factory =
                    new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                // 解析切面类中所有的通知--一个通知生成一个Advisor.
                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);

                // 加入到缓存中
                if (this.beanFactory.isSingleton(beanName)) {
                  this.advisorsCache.put(beanName, classAdvisors);
                } else {
                  this.aspectFactoryCache.put(beanName, factory);
                }
                advisors.addAll(classAdvisors);
              } else {
                // Per target or per this.
                if (this.beanFactory.isSingleton(beanName)) {
                  throw new IllegalArgumentException("Bean with name '" + beanName +
                      "' is a singleton, but aspect instantiation model is not singleton");
                }
                MetadataAwareAspectInstanceFactory factory =
                    new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                this.aspectFactoryCache.put(beanName, factory);
                advisors.addAll(this.advisorFactory.getAdvisors(factory));
              }
            }
          }
          this.aspectBeanNames = aspectNames;
          return advisors;
        }
      }
    }

    if (aspectNames.isEmpty()) {
      return Collections.emptyList();
    }
    List<Advisor> advisors = new ArrayList<>();
    for (String aspectName : aspectNames) {
      List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
      if (cachedAdvisors != null) {
        advisors.addAll(cachedAdvisors);
      } else {
        MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
        advisors.addAll(this.advisorFactory.getAdvisors(factory));
      }
    }
    return advisors;
  }