一个很有意思的Spring注入问题，你遇到过吗？

static interface DAO {}
static class CommonDAO implements DAO {}
@Configuration
static class AppConfig {
  @Bean
  DAO dao() {
    return new CommonDAO() ;
  }
}
static class CommonService {
  @Resource
  private DAO dao ;
  @Resource
  private CommonDAO commonDAO ;
}
try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
  context.registerBean(AppConfig.class) ;
  context.registerBean(CommonService.class) ;
  context.refresh() ;
}

static class CommonService {
  @Resource
  private CommonDAO commonDAO ;
}

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.pack.main.bean_propertyvalue_inject.InterfaceAndImplInject$CommonDAO' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@javax.annotation.Resource(shareable=true, lookup=, name=, description=, authenticationType=CONTAINER, type=class java.lang.Object, mappedName=)}
  at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoMatchingBeanFound(DefaultListableBeanFactory.java:1801)
  at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1357)

static class CommonService {
  @Resource
  private CommonDAO dao;
}

static class CommonService {
  @Resource
  private CommonDAO commonDAO ;
  @Resource
  private DAO dao ;
}

@Configuration
static class AppConfig {
  @Bean
  CommonService commonService() {
    return new CommonService() ;
  }
  @Bean
  DAO dao() {
    return new CommonDAO() ;
  }
}
static class CommonService {
  @Resource
  private CommonDAO commonDAO ;
}

@Configuration
static class AppConfig {
  @Bean
  DAO dao() {
    return new CommonDAO() ;
  }
  @Bean
  CommonService commonService() {
    return new CommonService() ;
  }
}

@Resource
private DAO dao ;
@Resource
private CommonDAO commonDAO ;

public class CommonAnnotationBeanPostProcessor {
  protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName) {
    Object resource;


    if (factory instanceof AutowireCapableBeanFactory) {
      AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
      DependencyDescriptor descriptor = element.getDependencyDescriptor();
      // 判断你当前注入属性的名字(beanName) 在容器中是否存在。这里取反了，如果不存在时进行类型的查找
      if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
        resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
      } else {
        // 存在，直接通过beanName(这里就是字段名)查找
        resource = beanFactory.resolveBeanByName(name, descriptor);
        autowiredBeanNames = Collections.singleton(name);
      }
    }
    return resource;
  }
}

public abstract class AbstractAutowireCapableBeanFactory {
  public Object resolveBeanByName(String name, DependencyDescriptor descriptor) {
    return getBean(name, descriptor.getDependencyType());
  }
}
public abstract class AbstractBeanFactory {
  public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    return doGetBean(name, requiredType, null, false);
  }
  protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) {
    // 这里就是先从单例池中获取指定beanName是否存在，如果不存在则进行创建bean实例。
    // 创建完成后将当前的实例存入单例池中。
  }
}

public class DefaultListableBeanFactory {
  public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
    @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    // ...
    Object result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
  }
  public Object doResolveDependency(...) {
    // ...
    Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
  }
  protected Map<String, Object> findAutowireCandidates(
    @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
    // 通过类型查找beanNames, 当前reqiredType=CommonDAO
    String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
        this, requiredType, true, descriptor.isEager());
  }
}
public abstract class BeanFactoryUtils {
  public static String[] beanNamesForTypeIncludingAncestors(
      ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
    // 通过类型查找
    String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
    return result;
  }
}
public class DefaultListableBeanFactory {
  public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
    // 通过类型查找
    String[] resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
    return resolvedBeanNames;
  }
  private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
    // 遍历所有的BeanDefinition（这是Spring容器对每一个bena的元数据了）
    for (String beanName : this.beanDefinitionNames) {
      RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName) ;
      // 关键代码
      matchFound = isTypeMatch(beanName, type, true);
    }
  }
  protected boolean isTypeMatch(String name, ...) {
    // beanName = dao
    String beanName = transformedBeanName(name);
    // 从单例池中获取实例，这里肯定可以获取，我们第一个属性注入的就是
    // DAO,所以这里就返回了CommonDAO实例
    Object beanInstance = getSingleton(beanName, false);
    if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
      // 这里肯定是实例对象，直接返回了
      if (typeToMatch.isInstance(beanInstance)) {
        return true;
      }
    }
  }
}