关于java:NoUniqueBeanDefinitionException-分析

“Spring 对于 NoUniqueBeanDefinition（不惟一的 Bean）的解决”

Spring IoC容器有两种实现依赖管制的办法，一种是依赖注入，一种是依赖查找，在默认状况下，当某个类型的 Bean 存在多个的状况下，都可能会产生NoUniqueBeanDefinitionException。

应用谬误倒推的办法看看依赖注入以及依赖查找对不惟一 Bean 的解决。

谬误点：在依赖注入解决多个 Bean 时，当所有计划都没用（啥都没配置时），会应用 DependencyDescriptor#resolveNotUnique 抛出异样

public class DependencyDescriptor extends InjectionPoint implements Serializable {
......
    @Nullable
    public Object resolveNotUnique(ResolvableType type, Map<String, Object> matchingBeans) throws BeansException {throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
    }

......
}

剖析入口：DefaultListableBeanFactory#doResolveDependency

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
   try {
      ......

          // 解析是否汇合类型（包含 Map）类型的 Bean，是返回 Bean 汇合
      Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
      if (multipleBeans != null) {return multipleBeans;}

       // 获取能够进行依赖注入符合条件的所有 Bean
      Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
      if (matchingBeans.isEmpty()) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
         }
         return null;
      }

      String autowiredBeanName;
      Object instanceCandidate;

      if (matchingBeans.size() > 1) {
          // 若不止一个 Bean，从中决定一个 Bean 进行注入
         autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
         if (autowiredBeanName == null) {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;
            }
         }
         instanceCandidate = matchingBeans.get(autowiredBeanName);
      }
      else {
         // We have exactly one match.
         Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
         autowiredBeanName = entry.getKey();
         instanceCandidate = entry.getValue();}

      ......
      return result;
   }
   finally {ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
   }
}

查找适合的 Bean，会依据autowireCandidate 进行判断 Bean 是否能用于主动拆卸。isAutowireCandidate办法进过一系列调用会应用 AutowireCandidateResolver 进行判断，默认应用 ContextAnnotationAutowireCandidateResolver，蕴含了autowireCandidate 判断，以及 @Qualifier 判断。

protected Map<String, Object> findAutowireCandidates(@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

    // 先把合乎类型的 Bean 都查问进去
   String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this, requiredType, true, descriptor.isEager());
   Map<String, Object> result = CollectionUtils.newLinkedHashMap(candidateNames.length);
   ......
       
   for (String candidate : candidateNames) {
       //isAutowireCandidate 会先依据 autowireCandidate 判断，而后会应用 @Qualifier 判断，若容许则退出 result 中
      if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {addCandidateEntry(result, candidate, descriptor, requiredType);
      }
   }
   if (result.isEmpty()) {
       // 后续保险匹配，可疏忽
      boolean multiple = indicatesMultipleBeans(requiredType);
      // Consider fallback matches if the first pass failed to find anything...
      DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
      for (String candidate : candidateNames) {if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
               (!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {addCandidateEntry(result, candidate, descriptor, requiredType);
         }
      }
      if (result.isEmpty() && !multiple) {
         // Consider self references as a final pass...
         // but in the case of a dependency collection, not the very same bean itself.
         for (String candidate : candidateNames) {if (isSelfReference(beanName, candidate) &&
                  (!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
                  isAutowireCandidate(candidate, fallbackDescriptor)) {addCandidateEntry(result, candidate, descriptor, requiredType);
            }
         }
      }
   }
   return result;
}

AutowireCandidateResolver

默认依据 BeanDefinition#autowireCandidate 判断，子类 QualifierAnnotationAutowireCandidateResolver 提供 @Qualifier 解决能力，默认 ContextAnnotationAutowireCandidateResolver 继承QualifierAnnotationAutowireCandidateResolver。

public interface AutowireCandidateResolver {

   /**
    * Determine whether the given bean definition qualifies as an
    * autowire candidate for the given dependency.
    * <p>The default implementation checks
    * {@link org.springframework.beans.factory.config.BeanDefinition#isAutowireCandidate()}.
    * @param bdHolder the bean definition including bean name and aliases
    * @param descriptor the descriptor for the target method parameter or field
    * @return whether the bean definition qualifies as autowire candidate
    * @see org.springframework.beans.factory.config.BeanDefinition#isAutowireCandidate()
    */
   default boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {return bdHolder.getBeanDefinition().isAutowireCandidate();}
}

蕴含了Primary、@Priority、名称匹配三种策略

/**
 * Determine the autowire candidate in the given set of beans.
 * <p>Looks for {@code @Primary} and {@code @Priority} (in that order).
 * @param candidates a Map of candidate names and candidate instances
 * that match the required type, as returned by {@link #findAutowireCandidates}
 * @param descriptor the target dependency to match against
 * @return the name of the autowire candidate, or {@code null} if none found
 */
@Nullable
protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {Class<?> requiredType = descriptor.getDependencyType();
    // 是否指定了 Primary
   String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
   if (primaryCandidate != null) {return primaryCandidate;}
    // 是否有应用 @Priority 指定优先级
   String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
   if (priorityCandidate != null) {return priorityCandidate;}
   // Fallback
   for (Map.Entry<String, Object> entry : candidates.entrySet()) {String candidateName = entry.getKey();
      Object beanInstance = entry.getValue();
       // 最初兜底，应用 BeanName 和注入属性的名称进行匹配
      if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
            matchesBeanName(candidateName, descriptor.getDependencyName())) {return candidateName;}
   }
   return null;
}

依赖查找有两种，一种是指定 Bean 的名称查找，不存在不惟一的状况，另一种便是依据类型去查找，可能会呈现NoUniqueBeanDefinitionException。

谬误点：resolveNamedBean抛出异样

剖析入口：DefaultListableBeanFactory#resolveNamedBean

依据类型 getBean，最终会调用resolveNamedBean 获取 NamedBeanHolder 以取得对应的 Bean，当存在多个 Bean 时，此办法顺次依据BeanDefinition#autowireCandidate、Primary 以及 Priority 进行解决，在无奈决定的状况下会报错。

private <T> NamedBeanHolder<T> resolveNamedBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {Assert.notNull(requiredType, "Required type must not be null");
   String[] candidateNames = getBeanNamesForType(requiredType);

   if (candidateNames.length > 1) {List<String> autowireCandidates = new ArrayList<>(candidateNames.length);
      for (String beanName : candidateNames) {
          // 判断 BeanDefinition#autowireCandidate
         if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) {autowireCandidates.add(beanName);
         }
      }
      if (!autowireCandidates.isEmpty()) {candidateNames = StringUtils.toStringArray(autowireCandidates);
      }
   }

   if (candidateNames.length == 1) {return resolveNamedBean(candidateNames[0], requiredType, args);
   }
   else if (candidateNames.length > 1) {Map<String, Object> candidates = CollectionUtils.newLinkedHashMap(candidateNames.length);
      for (String beanName : candidateNames) {if (containsSingleton(beanName) && args == null) {Object beanInstance = getBean(beanName);
            candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance));
         }
         else {candidates.put(beanName, getType(beanName));
         }
      }
       // 判断 Primary
      String candidateName = determinePrimaryCandidate(candidates, requiredType.toClass());
      if (candidateName == null) {
          // 依据 @Priority 筛选优先级最高的
         candidateName = determineHighestPriorityCandidate(candidates, requiredType.toClass());
      }
      if (candidateName != null) {Object beanInstance = candidates.get(candidateName);
         if (beanInstance == null) {return null;}
         if (beanInstance instanceof Class) {return resolveNamedBean(candidateName, requiredType, args);
         }
         return new NamedBeanHolder<>(candidateName, (T) beanInstance);
      }
      if (!nonUniqueAsNull) {throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
      }
   }

   return null;
}

对于NoUniqueBeanDefinitionException，咱们有多种解决形式，按依赖注入 & 依赖查找来讲

依赖注入（按程序）
1. BeanDefinition#autowireCandidate属性设置，只保留一个为 true 的
2. @Qualifier注解进行解决
3. 指定 Primary 的Bean
4. @Priority注解指定程序
5. 兜底名称匹配
依赖查找 - 按类型（按程序）
1. BeanDefinition#autowireCandidate属性设置，只保留一个为 true 的
2. 指定 Primary 的Bean
3. @Priority注解指定程序

References

https://tablesheep233.github….

原创不易，禁止未受权的转载。如果我的文章对您有帮忙，就请点赞 / 珍藏 / 关注激励反对一下吧

关于java:NoUniqueBeanDefinitionException-分析

NoUniqueBeanDefinitionException

依赖注入剖析

doResolveDependency

findAutowireCandidates

AutowireCandidateResolver

determineAutowireCandidate

依赖查找剖析

resolveNamedBean

总结