源码解析异常expected single matching bean but found 2是如何发生的

前言

这篇博客是对【@Resource 源码解析】做的另一个补丁。主要会讲解在使用@Resource的时候发生的expected single matching bean but found 2异常在源码层面是一个怎么样子的过程。为什么要用@Resource讲解，因为这个注解比较好模拟异常的发生，实际上@Autowired发生的原理也是一样的。更多Spring内容进入【Spring解读系列目录】。

问题还原

首先要有一个接口Demo，然后有两个实现类DemoImpl1和DemoImpl2，以及一个DemoService去依赖Demo。当我们在上面的例子中使用@Resource时，如果变量名字不符合Spring命名规则，而项目里也没有指定一个命名规则怎么办。这个问题其实很容易模拟，比如修改一下DemoService的内容如下。

public class DemoService {
    @Resource
    Demo demo;
}

报错实例

Spring自动注入其实还有一个常见的问题，那就是expected single matching bean but found 2的异常。类似上述例子的写法，当Spring容器不知道应该为接口注入哪个实例对象的时候就会报下面的异常

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'demoService': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.example.bean.Demo' available: expected single matching bean but found 2: demoImpl1,demoImpl2
   at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessProperties(CommonAnnotationBeanPostProcessor.java:321)
   at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1415)
   at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:608)
   at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:531)
   at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
   at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
   at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
   at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
   at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:944)
   at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:925)
   at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:588)
   at org.springframework.context.annotation.AnnotationConfigApplicationContext.<init>(AnnotationConfigApplicationContext.java:93)
   at com.example.test.Test.main(Test.java:9)
Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.example.bean.Demo' available: expected single matching bean but found 2: demoImpl1,demoImpl2
   at org.springframework.beans.factory.config.DependencyDescriptor.resolveNotUnique(DependencyDescriptor.java:220)
   at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1345)
   at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1287)
   at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:521)
   at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:497)
   at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor$ResourceElement.getResourceToInject(CommonAnnotationBeanPostProcessor.java:650)
   at org.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(InjectionMetadata.java:229)
   at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:119)
   at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessProperties(CommonAnnotationBeanPostProcessor.java:318)
   ... 12 more

Spring调用链

这个异常又是怎么发生的呢？首先还是要拿出来调用链。

autowireResource:521, CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
getResource:497, CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
getResourceToInject:650, CommonAnnotationBeanPostProcessor$ResourceElement (org.springframework.context.annotation)
inject:229, InjectionMetadata$InjectedElement (org.springframework.beans.factory.annotation)
inject:119, InjectionMetadata (org.springframework.beans.factory.annotation)
postProcessProperties:318, CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
populateBean:1415, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:608, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBean:531, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
lambda$doGetBean$0:335, AbstractBeanFactory (org.springframework.beans.factory.support)
getObject:-1, 232307208 (org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$34)
getSingleton:234, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
doGetBean:333, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean:208, AbstractBeanFactory (org.springframework.beans.factory.support)
preInstantiateSingletons:944, DefaultListableBeanFactory (org.springframework.beans.factory.support)
finishBeanFactoryInitialization:925, AbstractApplicationContext (org.springframework.context.support)
refresh:588, AbstractApplicationContext (org.springframework.context.support)
<init>:93, AnnotationConfigApplicationContext (org.springframework.context.annotation)
main:9, Test (com.example.test)

源码追踪

根据调用链可以看出最终还是到了autowireResource()这个方法里面。

protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
      throws NoSuchBeanDefinitionException {
   Object resource;
   Set<String> autowiredBeanNames;
   String name = element.name;
   if (factory instanceof AutowireCapableBeanFactory) {
      AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
      DependencyDescriptor descriptor = element.getDependencyDescriptor();
	//关键点就在于Demo是一个接口无法被实例化，因此进入了到if块了
      if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
         autowiredBeanNames = new LinkedHashSet<>();
         resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
         if (resource == null) {
            throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
         }
      }
      else {
         resource = beanFactory.resolveBeanByName(name, descriptor);
         autowiredBeanNames = Collections.singleton(name);
      }
   }
   /**略**/
   return resource;
}

这里基本上没有大的差别，区别就在于factory.containsBean(name)无法取到值，因为Demo是一个接口，因此demo无法作为一个实例存在于Spring容器里。所以会走到if语句内，因此执行的resource赋值方法就是beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null)。

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
   if (Optional.class == descriptor.getDependencyType()) {
      return createOptionalDependency(descriptor, requestingBeanName);
   }
   else if (ObjectFactory.class == descriptor.getDependencyType() ||
         ObjectProvider.class == descriptor.getDependencyType()) {
      return new DependencyObjectProvider(descriptor, requestingBeanName);
   }
   else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
      return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
   }
   else {
      Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
            descriptor, requestingBeanName);
      if (result == null) { //最终会走到这里
         result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
      }
      return result;
   }
}

经过一些不会执行的if语句块以后，很明显这些条件都是Spring容器自己的，最终会走到doResolveDependency()方法里。这个方法是哪里的方法呢？就是@Autowired注解里找到matchingBeans的地方。也就是说最终@Resource在无法确定bean的名字的情况下，开始尝试进行byType的自动注入了。

if (matchingBeans.size() > 1) {
   autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
   if (autowiredBeanName == null) {
      if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
         return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans); //最终会在这里报错
      }
      else {
          return null;
      }
   }
   instanceCandidate = matchingBeans.get(autowiredBeanName);
}

由于找到自动匹配的对象超过一个，所以会走到resolveNotUnique()方法，而这里面唯一做的事情就是抛异常。

public Object resolveNotUnique(ResolvableType type, Map<String, Object> matchingBeans) throws BeansException {
   throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
}

那么反过来也就是说如果我们找到的对象是唯一的，比如下面的情况：

public class DemoService {
    @Resource
    Demo demo;
}

@Repository  //作为Demo接口的唯一实现
public class DemoImpl1 implements Demo{  
}

只有一个DemoImpl1作为Demo接口的实现类，那么此时由于matchingBeans.size()==1，我们的对象demo就直接会被赋值demoImpl1并返回出去，完成byType的注入。

相关异常解析链接：
【源码解析异常is expected to be of type ‘xxx’ but was actually of type ‘xxx’ 是如何发生的】