Spring QualifierAnnotationAutowireCandidateResolver

public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwareAutowireCandidateResolver {

	/**
	 * Qualifier 相关的注解类型
	 */
	private final Set<Class<? extends Annotation>> qualifierTypes = new LinkedHashSet<>(2);

	/**
	 * value 注解.class
	 */
	private Class<? extends Annotation> valueAnnotationType = Value.class;
}

	@Override
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		// 父类验证
		boolean match = super.isAutowireCandidate(bdHolder, descriptor);
		// 如果匹配
		if (match) {
			// 注解验证
			match = checkQualifiers(bdHolder, descriptor.getAnnotations());
			// 如果匹配
			if (match) {
				// 方法参数验证
				MethodParameter methodParam = descriptor.getMethodParameter();
				if (methodParam != null) {
					Method method = methodParam.getMethod();
					if (method == null || void.class == method.getReturnType()) {
						match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());
					}
				}
			}
		}
		return match;
	}

/**
 * Match the given qualifier annotations against the candidate bean definition.
 */
protected boolean checkQualifiers(BeanDefinitionHolder bdHolder, Annotation[] annotationsToSearch) {
   // 判空
   if (ObjectUtils.isEmpty(annotationsToSearch)) {
      return true;
   }
   // 类型转换器
   SimpleTypeConverter typeConverter = new SimpleTypeConverter();

   for (Annotation annotation : annotationsToSearch) {
      Class<? extends Annotation> type = annotation.annotationType();
      boolean checkMeta = true;
      boolean fallbackToMeta = false;
      // 注解类型是否在 qualifierTypes 中
      if (isQualifier(type)) {
         // 验证是否匹配
         if (!checkQualifier(bdHolder, annotation, typeConverter)) {
            fallbackToMeta = true;
         }
         else {
            checkMeta = false;
         }
      }
      //
      if (checkMeta) {
         boolean foundMeta = false;
         for (Annotation metaAnn : type.getAnnotations()) {
            Class<? extends Annotation> metaType = metaAnn.annotationType();
            if (isQualifier(metaType)) {
               foundMeta = true;
               // Only accept fallback match if @Qualifier annotation has a value...
               // Otherwise it is just a marker for a custom qualifier annotation.
               
               // StringUtils.isEmpty(AnnotationUtils.getValue(metaAnn)) 存在数据: Qualifier value 存在数据
               if ((fallbackToMeta && StringUtils.isEmpty(AnnotationUtils.getValue(metaAnn))) ||
                     !checkQualifier(bdHolder, metaAnn, typeConverter)) {
                  return false;
               }
            }
         }
         if (fallbackToMeta && !foundMeta) {
            return false;
         }
      }
   }
   return true;
}

// 第一部分
// 获取注解类型
Class<? extends Annotation> type = annotation.annotationType();
// 提取 bean 定义
RootBeanDefinition bd = (RootBeanDefinition) bdHolder.getBeanDefinition();

// 获取 AutowireCandidateQualifier . 通过类名的方式获取
// 从容器(qualifiers)中获取
AutowireCandidateQualifier qualifier = bd.getQualifier(type.getName());
if (qualifier == null) {
   // 没有获取到的话 通过类的短名字获取
   qualifier = bd.getQualifier(ClassUtils.getShortName(type));
}

private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();

@Nullable
protected Annotation getQualifiedElementAnnotation(RootBeanDefinition bd, Class<? extends Annotation> type) {
   AnnotatedElement qualifiedElement = bd.getQualifiedElement();
   return (qualifiedElement != null ? AnnotationUtils.getAnnotation(qualifiedElement, type) : null);
}

@Nullable
protected Annotation getFactoryMethodAnnotation(RootBeanDefinition bd, Class<? extends Annotation> type) {
   Method resolvedFactoryMethod = bd.getResolvedFactoryMethod();
   return (resolvedFactoryMethod != null ? AnnotationUtils.getAnnotation(resolvedFactoryMethod, type) : null);
}

if (targetAnnotation != null && targetAnnotation.equals(annotation)) {
   return true;
}