JavaSpring各种依赖注入注解的区别

Spring对于Bean的依赖注入，支持多种注解方式：

 
 
    
  
  
  1. @Resource
    2. 
  
  
  2. javax.annotation
    3. 
  
  
  3. JSR250 (Common Annotations for Java)
    4. 
  
  
  4. 
  
  
  5. @Inject
    6. 
  
  
  6. javax.inject
    7. 
  
  
  7. JSR330 (Dependency Injection for Java)
    8. 
  
  
  8. 
  
  
  9. @Autowired
    10. 
  
  
  10. org.springframework.bean.factory
    11. 
  
  
  11. Spring
    12.

直观上看起来，@Autowired是Spring提供的注解，其他几个都是JDK本身内建的注解，Spring对这些注解也进行了支持。但是使用起来这三者到底有什么区别呢？笔者经过方法的测试，发现一些有意思的特性。

区别总结如下：

一、@Autowired有个required属性，可以配置为false，这种情况下如果没有找到对应的bean是不会抛异常的。@Inject和@Resource没有提供对应的配置，所以必须找到否则会抛异常。

二、 @Autowired和@Inject基本是一样的，因为两者都是使用AutowiredAnnotationBeanPostProcessor来处理 依赖注入。但是@Resource是个例外，它使用的是CommonAnnotationBeanPostProcessor来处理依赖注入。当然，两者 都是BeanPostProcessor。

 
 
    
  
  
  1. @Autowired和@Inject
    2. 
  
  
  2. - 默认 autowired by type
    3. 
  
  
  3. - 可以 通过@Qualifier 显式指定 autowired by qualifier name。
    4. 
  
  
  4. - 如果 autowired by type 失败（找不到或者找到多个实现），则退化为autowired by field name
    5. 
  
  
  5. 
  
  
  6. @Resource
    7. 
  
  
  7. - 默认 autowired by field name
    8. 
  
  
  8. - 如果 autowired by field name失败，会退化为 autowired by type
    9. 
  
  
  9. - 可以 通过@Qualifier 显式指定 autowired by qualifier name
    10. 
  
  
  10. - 如果 autowired by qualifier name失败，会退化为 autowired by field name。但是这时候如果 autowired by field name失败，就不会再退化为autowired by type了。
    11.

TIPS Qualified name VS Bean name

在Spring设计中，Qualified name并不等同于Bean name，后者必须是***的，但是前者类似于tag或者group的作用，对特定的bean进行分类。可以达到getByTag(group)的效果。对 于XML配置的bean，可以通过id属性指定bean name（如果没有指定，默认使用类名首字母小写），通过标签指定qualifier name：

 
 
    
  
  
    2. 
  
  
  2.     
    3. 
  
  
  3.     
    4. 
  
  
  4.

如果是通过注解方式，那么可以通过@Qualifier注解指定qualifier name，通过@Named或者@Component（@Service，@Repository等）的value值指定bean name：

 
 
    
  
  
  1. @Component("lamborghini")
    2. 
  
  
  2. @Qualifier("luxury")
    3. 
  
  
  3. public class Lamborghini implements Car {
    4. 
  
  
  4. }
    5.

或者

 
 
    
  
  
  1. @Component
    2. 
  
  
  2. @Named("lamborghini")
    3. 
  
  
  3. @Qualifier("luxury")
    4. 
  
  
  4. public class Lamborghini implements Car {
    5. 
  
  
  5. }
    6.

同样，如果没有指定bean name，那么Spring会默认是用类名首字母小写(Lamborghini=>lamborghini)。

三、 通过Anotation注入依赖的方式在XML注入方式之前进行。如果对同一个bean的依赖同时使用了两种注入方式，那么XML的优先。但是不同担心通过Anotation注入的依赖没法注入XML中配置的bean，依赖注入是在bean的注册之后进行的。

四、目前的autowired by type方式（笔者用的是3.2.3.RELEASE版本），Spring的AutowiredAnnotationBeanPostProcessor 实现都是有”bug”的，也就是说@Autowired和@Inject都是有坑的（称之为坑，不称之为bug是因为貌似是故意的。。）。这是来源于线上 的一个bug，也是这边文章的写作原因。现场如下：

application-context.xml中有如下定义：

 
 
    
  
  
    2. 
  
  
  2. 
  
  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    4. 
  
  
  4.     xmlns:context="http://www.springframework.org/schema/context"
    5. 
  
  
  5.     xmlns:util="http://www.springframework.org/schema/util"
    6. 
  
  
  6.     xsi:schemaLocation="
    7. 
  
  
  7.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    8. 
  
  
  8.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    9. 
  
  
  9.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
    10. 
  
  
  10.         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">
    11. 
  
  
  11. 
  
  
  12.     
    13. 
  
  
  13. 
  
  
  14.     
    15. 
  
  
  15. 
  
  
  16.     
  
  
  17.         static-field="me.arganzheng.study.spring.autowired.Constants.Language.EN" />
    18. 
  
  
  18.     
  
  
  19.         static-field="me.arganzheng.study.spring.autowired.Constants.Language.JP" />
    20. 
  
  
  20.     
  
  
  21.         static-field="me.arganzheng.study.spring.autowired.Constants.Language.IND" />
    22. 
  
  
  22.     
  
  
  23.         static-field="me.arganzheng.study.spring.autowired.Constants.Language.PT" />
    24. 
  
  
  24.     
  
  
  25.         static-field="me.arganzheng.study.spring.autowired.Constants.Language.TH" />
    26. 
  
  
  26.     
  
  
  27.         static-field="me.arganzheng.study.spring.autowired.Constants.Language.AR" />
    28. 
  
  
  28.     
  
  
  29.         static-field="me.arganzheng.study.spring.autowired.Constants.Language.EN_RIN" />
    30. 
  
  
  30. 
  
  
  31.     
  
  
  32.         value-type="java.lang.String">
    33. 
  
  
  33.         
    34. 
  
  
  34.         
    35. 
  
  
  35.         
    36. 
  
  
  36.         
    37. 
  
  
  37.         
    38. 
  
  
  38.         
    39. 
  
  
  39.         
    40. 
  
  
  40.         
    41. 
  
  
  41.         
    42. 
  
  
  42.         
    43. 
  
  
  43.         
    44. 
  
  
  44.         
    45. 
  
  
  45.         
    46. 
  
  
  46.     
    47. 
  
  
  47. 
  
  
  48.

其中static-field应用的常量定义在如下类中：

 
 
    
  
  
  1. package me.arganzheng.study.spring.autowired;
    2. 
  
  
  2. 
  
  
  3. public interface Constants {
    4. 
  
  
  4. 
  
  
  5.     public interface Language {
    6. 
  
  
  6.         public static final String EN = "CommonConstants.LANG_ENGLISH";
    7. 
  
  
  7.         public static final String JP = "CommonConstants.LANG_JAPANESE";
    8. 
  
  
  8.         public static final String IND = "CommonConstants.LANG_INDONESIAN";
    9. 
  
  
  9.         public static final String PT = "CommonConstants.LANG_PORTUGUESE";
    10. 
  
  
  10.         public static final String TH = "CommonConstants.LANG_THAI";
    11. 
  
  
  11.         public static final String EN_RIN = "CommonConstants.LANG_ENGLISH_INDIA";
    12. 
  
  
  12.         public static final String AR = "CommonConstants.LANG_Arabic";
    13. 
  
  
  13.     }
    14. 
  
  
  14. }
    15.

然后如果我们在代码中如下声明依赖：

 
 
    
  
  
  1. public class AutowiredTest extends BaseSpringTestCase {
    2. 
  
  
  2. 
  
  
  3.     @Autowired
    4. 
  
  
  4.     private Map languageChangesMap;
    5. 
  
  
  5. 
  
  
  6.     @Test
    7. 
  
  
  7.     public void testAutowired() {
    8. 
  
  
  8.         notNull(languageChangesMap);
    9. 
  
  
  9.         System.out.println(languageChangesMap.getClass().getSimpleName());
    10. 
  
  
  10.         System.out.println(languageChangesMap);
    11. 
  
  
  11.     }
    12. 
  
  
  12. }
    13.

Guess what，诡异的事情发生了！

运行结果如下：

 
 
    
  
  
  1. LinkedHashMap
    2. 
  
  
  2. {en=CommonConstants.LANG_ENGLISH, ja=CommonConstants.LANG_JAPANESE, ind=CommonConstants.LANG_INDONESIAN, pt=CommonConstants.LANG_PORTUGUESE, th=CommonConstants.LANG_THAI, ar=CommonConstants.LANG_Arabic, en-rIn=CommonConstants.LANG_ENGLISH_INDIA}
    3.

也就是说Map

 
 
    
  
  
  1. 严重: Caught exception while allowing TestExecutionListener [org.springframework.test.context.support.DependencyInjectionTestExecutionListener@5c51ee0a] to prepare test instance [me.arganzheng.study.spring.autowired.AutowiredTest@6e301e0]
    2. 
  
  
  2. org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'me.arganzheng.study.spring.autowired.AutowiredTest': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private java.util.Map me.arganzheng.study.spring.autowired.AutowiredTest.languageChangesMap; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [java.lang.String] found for dependency [map with value type java.lang.String]: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    3. 
 
 
 
 
    
  
  
  1. ...
    2. 
  
  
  2. ed by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [java.lang.String] found for dependency [map with value type java.lang.String]: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    3. 
  
  
  3. at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:986)
    4. 
  
  
  4. at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:843)
    5. 
  
  
  5. at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:768)
    6. 
  
  
  6. at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:486)
    7. 
  
  
  7. ... 28 more
    8.

debug了一下，发现确实是Spring的一个bug。在DefaultListableBeanFactory的这个方法出问题了：

 
 
    
  
  
  1. protected Object doResolveDependency(DependencyDescriptor descriptor, Class type, String beanName,
    2. 
  
  
  2.             Set autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
    3. 
  
  
  3.         ...    
    4. 
  
  
  4. 
  
  
  5.         else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
    6. 
  
  
  6.             Class keyType = descriptor.getMapKeyType();
    7. 
  
  
  7.             if (keyType == null || !String.class.isAssignableFrom(keyType)) {
    8. 
  
  
  8.                 if (descriptor.isRequired()) {
    9. 
  
  
  9.                     throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +
    10. 
  
  
  10.                             "] must be assignable to [java.lang.String]");
    11. 
  
  
  11.                 }
    12. 
  
  
  12.                 return null;
    13. 
  
  
  13.             }
    14. 
  
  
  14.             Class valueType = descriptor.getMapValueType();
    15. 
  
  
  15.             if (valueType == null) {
    16. 
  
  
  16.                 if (descriptor.isRequired()) {
    17. 
  
  
  17.                     throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");
    18. 
  
  
  18.                 }
    19. 
  
  
  19.                 return null;
    20. 
  
  
  20.             }
    21. 
  
  
  21.             Map matchingBeans = findAutowireCandidates(beanName, valueType, descriptor);
    22. 
  
  
  22.             if (matchingBeans.isEmpty()) {
    23. 
  
  
  23.                 if (descriptor.isRequired()) {
    24. 
  
  
  24.                     raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);
    25. 
  
  
  25.                 }
    26. 
  
  
  26.                 return null;
    27. 
  
  
  27.             }
    28. 
  
  
  28.             if (autowiredBeanNames != null) {
    29. 
  
  
  29.                 autowiredBeanNames.addAll(matchingBeans.keySet());
    30. 
  
  
  30.             }
    31. 
  
  
  31.             return matchingBeans;
    32. 
  
  
  32.         }
    33. 
  
  
  33.         ...
    34. 
  
  
  34.     }
    35.

关键在这一句：Map

 
 
    
  
  
  1. 严重: Caught exception while allowing TestExecutionListener [org.springframework.test.context.support.DependencyInjectionTestExecutionListener@9476189] to prepare test instance [me.arganzheng.study.spring.autowired.AutowiredTest@2d546e21]
    2. 
  
  
  2. ...
    3. 
  
  
  3. Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [java.lang.String] found for dependency [map with value type java.lang.String]: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true), @org.springframework.beans.factory.annotation.Qualifier(value=languageChangesMap)}
    4. 
  
  
  4.     at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:986)
    5. 
  
  
  5.     at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:843)
    6. 
  
  
  6.     at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:768)
    7. 
  
  
  7.     at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:486)
    8. 
  
  
  8.     ... 28 more
    9.

debug了一下，发现跟没有指定qualifie name是一样的执行路径。不是指定了bean name了吗？为什么还是autowired by type呢？仔细查看了一下才发现。DefaultListableBeanFactory的doResolveDependency方法对首先对类型做 了区别：

 
 
    
  
  
  1. protected Object doResolveDependency(DependencyDescriptor descriptor, Class type, String beanName,
    2. 
  
  
  2.             Set autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
    3. 
  
  
  3. 
  
  
  4.         Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
    5. 
  
  
  5.         if (value != null) {
    6. 
  
  
  6.             if (value instanceof String) {
    7. 
  
  
  7.                 String strVal = resolveEmbeddedValue((String) value);
    8. 
  
  
  8.                 BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
    9. 
  
  
  9.                 value = evaluateBeanDefinitionString(strVal, bd);
    10. 
  
  
  10.             }
    11. 
  
  
  11.             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
    12. 
  
  
  12.             return (descriptor.getField() != null ?
    13. 
  
  
  13.                     converter.convertIfNecessary(value, type, descriptor.getField()) :
    14. 
  
  
  14.                     converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
    15. 
  
  
  15.         }
    16. 
  
  
  16. 
  
  
  17.         if (type.isArray()) {
    18. 
  
  
  18.             Class componentType = type.getComponentType();
    19. 
  
  
  19.             Map matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
    20. 
  
  
  20.             if (matchingBeans.isEmpty()) {
    21. 
  
  
  21.                 if (descriptor.isRequired()) {
    22. 
  
  
  22.                     raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);
    23. 
  
  
  23.                 }
    24. 
  
  
  24.                 return null;
    25. 
  
  
  25.             }
    26. 
  
  
  26.             if (autowiredBeanNames != null) {
    27. 
  
  
  27.                 autowiredBeanNames.addAll(matchingBeans.keySet());
    28. 
  
  
  28.             }
    29. 
  
  
  29.             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
    30. 
  
  
  30.             return converter.convertIfNecessary(matchingBeans.values(), type);
    31. 
  
  
  31.         }
    32. 
  
  
  32.         else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
    33. 
  
  
  33.             Class elementType = descriptor.getCollectionType();
    34. 
  
  
  34.             if (elementType == null) {
    35. 
  
  
  35.                 if (descriptor.isRequired()) {
    36. 
  
  
  36.                     throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");
    37. 
  
  
  37.                 }
    38. 
  
  
  38.                 return null;
    39. 
  
  
  39.             }
    40. 
  
  
  40.             Map matchingBeans = findAutowireCandidates(beanName, elementType, descriptor);
    41. 
  
  
  41.             if (matchingBeans.isEmpty()) {
    42. 
  
  
  42.                 if (descriptor.isRequired()) {
    43. 
  
  
  43.                     raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);
    44. 
  
  
  44.                 }
    45. 
  
  
  45.                 return null;
    46. 
  
  
  46.             }
    47. 
  
  
  47.             if (autowiredBeanNames != null) {
    48. 
  
  
  48.                 autowiredBeanNames.addAll(matchingBeans.keySet());
    49. 
  
  
  49.             }
    50. 
  
  
  50.             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
    51. 
  
  
  51.             return converter.convertIfNecessary(matchingBeans.values(), type);
    52. 
  
  
  52.         }
    53. 
  
  
  53.         else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
    54. 
  
  
  54.             Class keyType = descriptor.getMapKeyType();
    55. 
  
  
  55.             if (keyType == null || !String.class.isAssignableFrom(keyType)) {
    56. 
  
  
  56.                 if (descriptor.isRequired()) {
    57. 
  
  
  57.                     throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +
    58. 
  
  
  58.                             "] must be assignable to [java.lang.String]");
    59. 
  
  
  59.                 }
    60. 
  
  
  60.                 return null;
    61. 
  
  
  61.             }
    62. 
  
  
  62.             Class valueType = descriptor.getMapValueType();
    63. 
  
  
  63.             if (valueType == null) {
    64. 
  
  
  64.                 if (descriptor.isRequired()) {
    65. 
  
  
  65.                     throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");
    66. 
  
  
  66.                 }
    67. 
  
  
  67.                 return null;
    68. 
  
  
  68.             }
    69. 
  
  
  69.             Map matchingBeans = findAutowireCandidates(beanName, valueType, descriptor);
    70. 
  
  
  70.             if (matchingBeans.isEmpty()) {
    71. 
  
  
  71.                 if (descriptor.isRequired()) {
    72. 
  
  
  72.                     raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);
    73. 
  
  
  73.                 }
    74. 
  
  
  74.                 return null;
    75. 
  
  
  75.             }
    76. 
  
  
  76.             if (autowiredBeanNames != null) {
    77. 
  
  
  77.                 autowiredBeanNames.addAll(matchingBeans.keySet());
    78. 
  
  
  78.             }
    79. 
  
  
  79.             return matchingBeans;
    80. 
  
  
  80.         }
    81. 
  
  
  81.         else {
    82. 
  
  
  82.             Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
    83. 
  
  
  83.             if (matchingBeans.isEmpty()) {
    84. 
  
  
  84.                 if (descriptor.isRequired()) {
    85. 
  
  
  85.                     raiseNoSuchBeanDefinitionException(type, "", descriptor);
    86. 
  
  
  86.                 }
    87. 
  
  
  87.                 return null;
    88. 
  
  
  88.             }
    89. 
  
  
  89.             if (matchingBeans.size() > 1) {
    90. 
  
  
  90.                 String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);
    91. 
  
  
  91.                 if (primaryBeanName == null) {
    92. 
  
  
  92.                     throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
    93. 
  
  
  93.                 }
    94. 
  
  
  94.                 if (autowiredBeanNames != null) {
    95. 
  
  
  95.                     autowiredBeanNames.add(primaryBeanName);
    96. 
  
  
  96.                 }
    97. 
  
  
  97.                 return matchingBeans.get(primaryBeanName);
    98. 
  
  
  98.             }
    99. 
  
  
  99.             // We have exactly one match.
    100. 
  
  
  100.             Map.Entry entry = matchingBeans.entrySet().iterator().next();
    101. 
  
  
  101.             if (autowiredBeanNames != null) {
    102. 
  
  
  102.                 autowiredBeanNames.add(entry.getKey());
    103. 
  
  
  103.             }
    104. 
  
  
  104.             return entry.getValue();
    105. 
  
  
  105.         }
    106. 
  
  
  106.     }
    107.

如果是Array，Collection或者Map，则根据集合类中元素的类型来进行autowired by type（Map使用value的类型）。为什么这么特殊处理呢？原来，Spring是为了达到这样的目的：让你可以一次注入所有符合类型的实现，也就是 说可以这样子注入：

 
 
    
  
  
  1. @Autowired
    2. 
  
  
  2. private List cars;
    3.

如果你的car有多个实现，那么都会注入进来，不会再报

 
 
    
  
  
  1. org.springframework.beans.factory.NoSuchBeanDefinitionException:
    2. 
  
  
  2. No unique bean of type [me.arganzheng.study.spring.autowired.Car] is defined:
    3. 
  
  
  3. expected single matching bean but found 2: [audi, toyota].
    4. 
  
  
  4. 
  
  
  5. 然而，上面的情况如果你用@Resource则不会有这个问题：
    6. 
  
  
  6. 
  
  
  7. public class AutowiredTest extends BaseSpringTestCase {
    8. 
  
  
  8. 
  
  
  9.     @Resource
    10. 
  
  
  10.     @Qualifier("languageChangesMap")
    11. 
  
  
  11.     private Map languageChangesMap;
    12. 
  
  
  12. 
  
  
  13.     @Test
    14. 
  
  
  14.     public void testAutowired() {
    15. 
  
  
  15.         assertNotNull(languageChangesMap);
    16. 
  
  
  16.         System.out.println(languageChangesMap.getClass().getSimpleName());
    17. 
  
  
  17.         System.out.println(languageChangesMap);
    18. 
  
  
  18.     }
    19. 
  
  
  19. }
    20.

正常运行：

 
 
    
  
  
  1. LinkedHashMap
    2. 
  
  
  2. {pt=pt, br=pt, jp=ja, ja=ja, ind=ind, id=ind, en-rin=en-rIn, in=en-rIn, en=en, gb=en, th=th, ar=ar, eg=ar}
    3.

当然，你如果不指定@Qualifier(“languageChangesMap”)，同时field name不是languageChangesMap，那么还是一样报错的。

 
 
    
  
  
  1. Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [java.lang.String] found for dependency [map with value type java.lang.String]: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@javax.annotation.Resource(shareable=true, mappedName=, description=, name=, type=class java.lang.Object, authenticationType=CONTAINER, lookup=)}
    2. 
  
  
  2. at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:986)
    3. 
  
  
  3. at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:843)
    4. 
  
  
  4. at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:768)
    5. 
  
  
  5. at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:438)
    6. 
  
  
  6. at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:416)
    7. 
  
  
  7. at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor$ResourceElement.getResourceToInject(CommonAnnotationBeanPostProcessor.java:550)
    8. 
  
  
  8. at org.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(InjectionMetadata.java:150)
    9. 
  
  
  9. at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:87)
    10. 
  
  
  10. at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessPropertyValues(CommonAnnotationBeanPostProcessor.java:303)
    11. 
  
  
  11. ... 26 more
    12.

而且，@Resource也可以实现上面的List接收所有实现：

 
 
    
  
  
  1. public class AutowiredTest extends BaseSpringTestCase {
    2. 
  
  
  2. 
  
  
  3.     @Resource
    4. 
  
  
  4.     @Qualifier("languageChangesMap")
    5. 
  
  
  5.     private Map languageChangesMap;
    6. 
  
  
  6. 
  
  
  7.     @Resource
    8. 
  
  
  8.     private List cars;
    9. 
  
  
  9. 
  
  
  10.     @Test
    11. 
  
  
  11.     public void testAutowired() {
    12. 
  
  
  12.         assertNotNull(languageChangesMap);
    13. 
  
  
  13.         System.out.println(languageChangesMap.getClass().getSimpleName());
    14. 
  
  
  14.         System.out.println(languageChangesMap);
    15. 
  
  
  15. 
  
  
  16.         assertNotNull(cars);
    17. 
  
  
  17.         System.out.println(cars.getClass().getSimpleName());
    18. 
  
  
  18.         System.out.println(cars);
    19. 
  
  
  19.     }
    20. 
  
  
  20. }
    21.

运行的妥妥的：

 
 
    
  
  
  1. LinkedHashMap
    2. 
  
  
  2. {pt=pt, br=pt, jp=ja, ja=ja, ind=ind, id=ind, en-rin=en-rIn, in=en-rIn, en=en, gb=en, th=th, ar=ar, eg=ar}
    3. 
  
  
  3. ArrayList
    4. 
  
  
  4. [me.arganzheng.study.spring.autowired.Audi@579584da, me.arganzheng.study.spring.autowired.Toyota@19453122]
    5.

这是因为@Resource注解使用的是CommonAnnotationBeanPostProcessor处理器，跟 AutowiredAnnotationBeanPostProcessor不是同一个作者[/偷笑]。这里就不分析了，感兴趣的同学可以自己看代码研究 一下。

最终结论如下：

1、@Autowired和@Inject

autowired by type 可以 通过@Qualifier 显式指定 autowired by qualifier name（非集合类。注意：不是autowired by bean name！）
如果 autowired by type 失败（找不到或者找到多个实现），则退化为autowired by field name（非集合类）

2、@Resource

默认 autowired by field name
如果 autowired by field name失败，会退化为 autowired by type
可以 通过@Qualifier 显式指定 autowired by qualifier name
如果 autowired by qualifier name失败，会退化为 autowired by field name。但是这时候如果 autowired by field name失败，就不会再退化为autowired by type了

测试工程保存在GitHub上，是标准的maven工程，感兴趣的同学可以clone到本地运行测试一下。

补充

有同事指出Spring官方文档上有这么一句话跟我的结有点冲突：

However, although you can use this convention to refer to specific beans by name, @Autowired is fundamentally about type-driven injection with optional semantic qualifiers. This means that qualifier values, even with the bean name fallback, always have narrowing semantics within the set of type matches; they do not semantically express a reference to a unique bean id.

也就是说@Autowired即使加了@Qualifier注解，其实也是autowired by type。@Qualifier只是一个限定词，过滤条件而已。重新跟进了一下代码，发现确实是这样子的。Spring设计的这个 @Qualifier name 并不等同于 bean name。他有点类似于一个tag。不过如果这个tag是***的化，那么其实效果上等同于bean name。实现上，Spring是先getByType，得到list candicates，然后再根据qualifier name进行过滤。

再定义一个兰博基尼，这里使用@Qualifier指定：

 
 
    
  
  
  1. package me.arganzheng.study.spring.autowired;
    2. 
  
  
  2. 
  
  
  3. import org.springframework.beans.factory.annotation.Qualifier;
    4. 
  
  
  4. import org.springframework.stereotype.Component;
    5. 
  
  
  5. 
  
  
  6. @Component
    7. 
  
  
  7. @Qualifier("luxury")
    8. 
  
  
  8. public class Lamborghini implements Car {
    9. 
  
  
  9. 
  
  
  10. }
    11.

再定义一个劳斯莱斯，这里故意用@Named指定：

 
 
    
  
  
  1. package me.arganzheng.study.spring.autowired;
    2. 
  
  
  2. 
  
  
  3. import javax.inject.Named;
    4. 
  
  
  4. 
  
  
  5. import org.springframework.stereotype.Component;
    6. 
  
  
  6. 
  
  
  7. @Component
    8. 
  
  
  8. @Named("luxury")
    9. 
  
  
  9. public class RollsRoyce implements Car {
    10. 
  
  
  10. 
  
  
  11. }
    12.

测试一下注入定义的豪华车：

 
 
    
  
  
  1. package me.arganzheng.study.spring.autowired;
    2. 
  
  
  2. 
  
  
  3. import static junit.framework.Assert.assertNotNull;
    4. 
  
  
  4. 
  
  
  5. import java.util.List;
    6. 
  
  
  6. 
  
  
  7. import me.arganzheng.study.BaseSpringTestCase;
    8. 
  
  
  8. 
  
  
  9. import org.junit.Test;
    10. 
  
  
  10. import org.springframework.beans.factory.annotation.Autowired;
    11. 
  
  
  11. import org.springframework.beans.factory.annotation.Qualifier;
    12. 
  
  
  12. 
  
  
  13. /**
    14. 
  
  
  14. *
    15. 
  
  
  15. * @author zhengzhibin
    16. 
  
  
  16. *
    17. 
  
  
  17. */
    18. 
  
  
  18. public class AutowiredTest extends BaseSpringTestCase {
    19. 
  
  
  19. 
  
  
  20.     @Autowired
    21. 
  
  
  21.     @Qualifier("luxury")
    22. 
  
  
  22.     private List luxuryCars;
    23. 
  
  
  23. 
  
  
  24.     @Test
    25. 
  
  
  25.     public void testAutowired() {
    26. 
  
  
                文章题目：JavaSpring各种依赖注入注解的区别
                
    
                文章来源：http://www.shufengxianlan.com/qtweb/news10/339260.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

网站策划知识

同城分类信息

解决方案　　 　东方电机技改服务有限公司　　 　虚拟主机　　 　app网站建设　　 　瑞杰管理　　 　成都画册设计公司　　 　甘孜州博瑞斯　　 　艾名斯线缆　　 　营销型网站建设　　 　成都网络营销　　 　免备案虚拟主机空间　　 　移动APP　　 　成都网站制作　　 　绵竹网站建设　　 　成都电商解决方案　　 　四川成都做网站　　 　网站制作　　 　四川胜锦安防　　 　鸿程源茂　　 　绵阳梓潼做网站