public interface AutowireCandidateResolver {
  // 默认情况下直接根据bd中的定义返回，如果没有进行特殊配置的话为true
  default boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    return bdHolder.getBeanDefinition().isAutowireCandidate();
  }
    // 指定的依赖是否是必要的
  default boolean isRequired(DependencyDescriptor descriptor) {
    return descriptor.isRequired();
  }
    // QualifierAnnotationAutowireCandidateResolver做了实现，判断是否有@Qualifier注解
    // 一共有两种注解：
    // 1.Spring内置的@Qualifier注解，org.springframework.beans.factory.annotation.Qualifier
    // 2.添加了JSR-330相关依赖，javax.inject.Qualifier注解
    // 默认情况下返回false
  default boolean hasQualifier(DependencyDescriptor descriptor) {
    return false;
  }
    // QualifierAnnotationAutowireCandidateResolver做了实现
    // 获取一个该依赖一个建议的值
  @Nullable
  default Object getSuggestedValue(DependencyDescriptor descriptor) {
    return null;
  }
    // 对某个依赖我们想要延迟注入，但是在创建Bean的过程中这个依赖又是必须的
    // 通过下面这个方法就能为延迟注入的依赖先生成一个代理注入到bean中
  @Nullable
  default Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
    return null;
  }
}

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
  @Override
  public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    return bdHolder.getBeanDefinition().isAutowireCandidate();
  }
  @Override
  public boolean isRequired(DependencyDescriptor descriptor) {
    return descriptor.isRequired();
  }
  @Override
  @Nullable
  public Object getSuggestedValue(DependencyDescriptor descriptor) {
    return null;
  }
  @Override
  @Nullable
  public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
    return null;
  }
}

public class GenericTypeAwareAutowireCandidateResolver extends SimpleAutowireCandidateResolver
    implements BeanFactoryAware {
  @Nullable
  private BeanFactory beanFactory;
  @Override
  public void setBeanFactory(BeanFactory beanFactory) {
    this.beanFactory = beanFactory;
  }
  @Nullable
  protected final BeanFactory getBeanFactory() {
    return this.beanFactory;
  }
  @Override
  public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    if (!super.isAutowireCandidate(bdHolder, descriptor)) {
      // 如果bd中已经配置了这个bean不做为依赖进行注入的话，直接返回false
      return false;
    }
        // 检查泛型是否匹配
    return checkGenericTypeMatch(bdHolder, descriptor);
  }
}

public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwareAutowireCandidateResolver {
  private final Set<Class<? extends Annotation>> qualifierTypes = new LinkedHashSet<>(2);
  // @Value注解
  private Class<? extends Annotation> valueAnnotationType = Value.class;
    // @Qualifier注解
  @SuppressWarnings("unchecked")
  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.
    }
  }
  // .......
  @Override
  public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
        // 类型上已经匹配了
    boolean match = super.isAutowireCandidate(bdHolder, descriptor);
    if (match) {
            // 还需要判断是否满足@Qualifier注解的要求
      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;
  }
  // .....
    // 是否是@Qualifier注解
  protected boolean isQualifier(Class<? extends Annotation> annotationType) {
    for (Class<? extends Annotation> qualifierType : this.qualifierTypes) {
      if (annotationType.equals(qualifierType) || annotationType.isAnnotationPresent(qualifierType)) {
        return true;
      }
    }
    return false;
  }
  @Override
  @Nullable
  public Object getSuggestedValue(DependencyDescriptor descriptor) {
    Object value = findValue(descriptor.getAnnotations());
    if (value == null) {
      MethodParameter methodParam = descriptor.getMethodParameter();
      if (methodParam != null) {
        value = findValue(methodParam.getMethodAnnotations());
      }
    }
    return value;
  }
    // 查找@Value注解
  @Nullable
  protected Object findValue(Annotation[] annotationsToSearch) {
    if (annotationsToSearch.length > 0) {   
      AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
          AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
      if (attr != null) {
        return extractValue(attr);
      }
    }
    return null;
  }
    // 获取@Value注解中的值
  protected Object extractValue(AnnotationAttributes attr) {
    Object value = attr.get(AnnotationUtils.VALUE);
    if (value == null) {
      throw new IllegalStateException("Value annotation must have a value attribute");
    }
    return value;
  }
}

public class ContextAnnotationAutowireCandidateResolver extends QualifierAnnotationAutowireCandidateResolver {
    // 如果依赖需要进行延迟处理，那么构建一个代理对象先注入到bean中，不会直接去创建依赖对象
  @Override
  @Nullable
  public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
    return (isLazy(descriptor) ? buildLazyResolutionProxy(descriptor, beanName) : null);
  }
    // 依赖是否需要延迟处理
  protected boolean isLazy(DependencyDescriptor descriptor) {
    for (Annotation ann : descriptor.getAnnotations()) {
      Lazy lazy = AnnotationUtils.getAnnotation(ann, Lazy.class);
      if (lazy != null && lazy.value()) {
        return true;
      }
    }
    MethodParameter methodParam = descriptor.getMethodParameter();
    if (methodParam != null) {
      Method method = methodParam.getMethod();
      if (method == null || void.class == method.getReturnType()) {
        Lazy lazy = AnnotationUtils.getAnnotation(methodParam.getAnnotatedElement(), Lazy.class);
        if (lazy != null && lazy.value()) {
          return true;
        }
      }
    }
    return false;
  }
    // 构建延迟处理的代理对象
  protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
    final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
        // 创建了一个TargetSource
    TargetSource ts = new TargetSource() {
      @Override
      public Class<?> getTargetClass() {
        return descriptor.getDependencyType();
      }
      @Override
      public boolean isStatic() {
        return false;
      }
            // target是我们实际想要使用的对象，如果不进行延迟处理，那么注入到bean中的应该就是这个对象
            // 但是因为要进行延迟注入依赖，所有会向外暴露一个TargetSource，这个TargetSource的目标为实际想要使用的对象，生成代理时会基于TargetSource进行生成。在运行期间（完成注入后）我们使用这个延迟处理的依赖时实际调用的会是target中的方法。
      @Override
      public Object getTarget() {
        Object target = beanFactory.doResolveDependency(descriptor, beanName, null, null);
        if (target == null) {
          Class<?> type = getTargetClass();
          if (Map.class == type) {
            return Collections.emptyMap();
          }
          else if (List.class == type) {
            return Collections.emptyList();
          }
          else if (Set.class == type || Collection.class == type) {
            return Collections.emptySet();
          }
          throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
              "Optional dependency not present for lazy injection point");
        }
        return target;
      }
      @Override
      public void releaseTarget(Object target) {
      }
    };
        // 使用ProxyFactory，给TargetSource生成一个代理
    ProxyFactory pf = new ProxyFactory();
    pf.setTargetSource(ts);
    Class<?> dependencyType = descriptor.getDependencyType();
        // 如果依赖的类型是一个接口，需要让代理类也实现这个接口
    if (dependencyType.isInterface()) {
      pf.addInterface(dependencyType);
    }
        // 生成代理
    return pf.getProxy(beanFactory.getBeanClassLoader());
  }
}