001 | 搭上SpringBoot自动注入源码分析专车

解析属性依赖 DefaultListableBeanFactory#doResolveDependency

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
 @Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

    InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
    try {
 // ...省略代码
 
 // 解析多个Bean，比如Array、List、Map类型，有兴趣可以自己查看分析
 Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
 if (multipleBeans != null) {
     return multipleBeans;
 }
 
 // 根据类型获取候选对象，针对studentService而言，该属性的类型为PersonService
 // PersonService有2个实现类，StudentServiceImpl和TeacherServiceImpl
 // 所以此处获取结果为StudentServiceImpl对象和TeacherServiceImpl对象
 Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
 if (matchingBeans.isEmpty()) {
     if (isRequired(descriptor)) {
  raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
     }
     return null;
 }

 String autowiredBeanName;
 Object instanceCandidate;
 // 重点处理，如果存在多个匹配的bean
 if (matchingBeans.size() > 1) {
     // 从已经匹配的bean中选择一个符合的bean
     autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
     if (autowiredBeanName == null) {
  // 如果bean必须注入或者存在多个匹配的bean，则抛出异常
  if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
      return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
  }
  else {
      // In case of an optional Collection/Map, silently ignore a non-unique case:
      // possibly it was meant to be an empty collection of multiple regular beans
      // (before 4.3 in particular when we didn't even look for collection beans).
      return null;
  }
     }
     // 根据bean名称获取对应的示例
     instanceCandidate = matchingBeans.get(autowiredBeanName);
 }
 else {
     // We have exactly one match.
     Map.Entry entry = matchingBeans.entrySet().iterator().next();
     autowiredBeanName = entry.getKey();
     instanceCandidate = entry.getValue();
 }

 if (autowiredBeanNames != null) {
     autowiredBeanNames.add(autowiredBeanName);
 }
 if (instanceCandidate instanceof Class) {
     instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
 }
 Object result = instanceCandidate;
 if (result instanceof NullBean) {
     if (isRequired(descriptor)) {
  raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
     }
     result = null;
 }
 if (!ClassUtils.isAssignablevalue(type, result)) {
     throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
 }
 // 返回对应的示例对象
 return result;
    }
    finally {
 ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
    }
}

protected String determineAutowireCandidate(Map candidates, DependencyDescriptor descriptor) {
    Class requiredType = descriptor.getDependencyType();
    // 如果bean对应的primary属性为true，则返回bean对应的名称
    String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
    if (primaryCandidate != null) {
 return primaryCandidate;
    }
    // 如果候选bean使用javax.annotation.Priority标注，返回高优先级bean对应的名称
    String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
    if (priorityCandidate != null) {
 return priorityCandidate;
    }
    // Fallback
    // 如果匹配bean的名称和需要注入的属性名称一致，则返回匹配bean的名称
    for (Map.Entry entry : candidates.entrySet()) {
 String candidateName = entry.getKey();
 Object beanInstance = entry.getValue();
 if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
  matchesBeanName(candidateName, descriptor.getDependencyName())) {
     return candidateName;
 }
    }
    return null;
}