@Qualifier高级应用---按类别批量依赖注入（QualifierAnnotationAutowireCandidateResolver原理详解）【享学Spring】（上）

@LoadBalanced
@Autowired(required = false)
private List<RestTemplate> restTemplates = Collections.emptyList(); 

// @since 2.5
public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwareAutowireCandidateResolver {
  // 是个List，可以知道它不仅仅只支持org.springframework.beans.factory.annotation.Qualifier
  private final Set<Class<? extends Annotation>> qualifierTypes = new LinkedHashSet<>(2);
  private Class<? extends Annotation> valueAnnotationType = Value.class;
  // 空构造：默认支持的是@Qualifier以及JSR330标准的@Qualifier
  public QualifierAnnotationAutowireCandidateResolver() {
    this.qualifierTypes.add(Qualifier.class);
    try {
      this.qualifierTypes.add((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Qualifier", QualifierAnnotationAutowireCandidateResolver.class.getClassLoader()));
    } catch (ClassNotFoundException ex) {
      // JSR-330 API not available - simply skip.
    }
  }
  // 非空构造：可自己额外指定注解类型
  // 注意：如果通过构造函数指定qualifierType，上面两种就不支持了，因此不建议使用
  // 而建议使用它提供的addQualifierType() 来添加~~~
  public QualifierAnnotationAutowireCandidateResolver(Class<? extends Annotation> qualifierType) {
  ... // 省略add/set方法  
  // 这是个最重要的接口方法~~~  判断所提供的Bean-->BeanDefinitionHolder 是否是候选的
  // （返回true表示此Bean符合条件）
  @Override
  public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    // 1、先看父类：ean定义是否允许依赖注入、泛型类型是否匹配
    boolean match = super.isAutowireCandidate(bdHolder, descriptor);
    // 2、若都满足就继续判断@Qualifier注解~~~~
    if (match) {
      // 3、看看标注的@Qualifier注解和候选Bean是否匹配~~~（本处的核心逻辑）
      // descriptor 一般封装的是属性写方法的参数，即方法参数上的注解
      match = checkQualifiers(bdHolder, descriptor.getAnnotations());
      // 4、若Field/方法参数匹配，会继续去看看参数所在的方法Method的情况
      // 若是构造函数/返回void。 进一步校验标注在构造函数/方法上的@Qualifier限定符是否匹配
    if (match) {
        MethodParameter methodParam = descriptor.getMethodParameter();
        // 若是Field，methodParam就是null  所以这里是需要判空的
        if (methodParam != null) {
          Method method = methodParam.getMethod();
          // method == null表示构造函数 void.class表示方法返回void
          if (method == null || void.class == method.getReturnType()) {
            // 注意methodParam.getMethodAnnotations()方法是可能返回空的
            // 毕竟构造方法/普通方法上不一定会标注@Qualifier等注解呀~~~~
            // 同时警示我们：方法上的@Qualifier注解可不要乱标
            match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());
          }
        }
      }
    }
    return match;
  }
  ...
}

QualifierAnnotationAutowireCandidateResolver：
  // 将给定的限定符注释与候选bean定义匹配。命名中你发现：这里是负数形式，表示多个注解一起匹配
  // 此处指的限定符，显然默认情况下只有@Qualifier注解
  protected boolean checkQualifiers(BeanDefinitionHolder bdHolder, Annotation[] annotationsToSearch) {
    // 很多人疑问为何没标注注解返回的还是true？
    // 请参照上面我的解释：methodParam.getMethodAnnotations()方法是可能返回空的，so...可以理解了吧
    if (ObjectUtils.isEmpty(annotationsToSearch)) {
      return true;
    }
    SimpleTypeConverter typeConverter = new SimpleTypeConverter();
    // 遍历每个注解（一般有@Autowired+@Qualifier两个注解）
    // 本文示例的两个注解：@Autowired+@LoadBalanced两个注解~~~（@LoadBalanced上标注有@Qualifier）
    for (Annotation annotation : annotationsToSearch) {
      Class<? extends Annotation> type = annotation.annotationType();
      boolean checkMeta = true; // 是否去检查元注解
      boolean fallbackToMeta = false;
      // isQualifier方法逻辑见下面：是否是限定注解（默认的/开发自己指定的）
      // 本文的org.springframework.cloud.client.loadbalancer.LoadBalanced是返回true的
      if (isQualifier(type)) {
        // checkQualifier：检查当前的注解限定符是否匹配
        if (!checkQualifier(bdHolder, annotation, typeConverter)) {
          fallbackToMeta = true; // 没匹配上。那就fallback到Meta去吧
        } else {
          checkMeta = false; // 匹配上了，就没必要校验元数据了喽~~~
        }
      }
      // 开始检查元数据（如果上面匹配上了，就不需要检查元数据了）
      // 比如说@Autowired注解/其它自定义的注解（反正就是未匹配上的），就会进来一个个检查元数据
      // 什么时候会到checkMeta里来：如@A上标注有@Qualifier。@B上标注有@A。这个时候限定符是@B的话会fallback过来
      if (checkMeta) {
        boolean foundMeta = false;
        // type.getAnnotations()结果为元注解们：@Documented、@Retention、@Target等等
        for (Annotation metaAnn : type.getAnnotations()) {
          Class<? extends Annotation> metaType = metaAnn.annotationType();
          if (isQualifier(metaType)) {
            foundMeta = true; // 只要进来了 就标注找到了，标记为true表示从元注解中找到了
            // Only accept fallback match if @Qualifier annotation has a value...
            // Otherwise it is just a marker for a custom qualifier annotation.
            // fallback=true(是限定符但是没匹配上才为true)但没有valeu值
            // 或者根本就没有匹配上，那不好意思，直接return false~
            if ((fallbackToMeta && StringUtils.isEmpty(AnnotationUtils.getValue(metaAnn))) || !checkQualifier(bdHolder, metaAnn, typeConverter)) {
              return false;
            }
          }
        }
        // fallbackToMeta =true你都没有找到匹配的，就返回false的
        if (fallbackToMeta && !foundMeta) {
          return false;
        }
      }
    }
    // 相当于：只有所有的注解都木有返回false，才会认为这个Bean是合法的~~~
    return true;
  }
  // 判断一个类型是否是限定注解   qualifierTypes：表示我所有支持的限定符
  // 本文的关键在于下面这个判断语句：类型就是限定符的类型 or @Qualifier标注在了此注解上（isAnnotationPresent）
  protected boolean isQualifier(Class<? extends Annotation> annotationType) {
    for (Class<? extends Annotation> qualifierType : this.qualifierTypes) {
      // 类型就是限定符的类型 or @Qualifier标注在了此注解上（isAnnotationPresent）
      if (annotationType.equals(qualifierType) || annotationType.isAnnotationPresent(qualifierType)) {
        return true;
      }
    }
    return false;
  }