日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
JavaSpring各種依賴注入注解的區(qū)別

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本身內(nèi)建的注解，Spring對這些注解也進(jìn)行了支持。但是使用起來這三者到底有什么區(qū)別呢？筆者經(jīng)過方法的測試，發(fā)現(xiàn)一些有意思的特性。

區(qū)別總結(jié)如下：

一、@Autowired有個required屬性，可以配置為false，這種情況下如果沒有找到對應(yīng)的bean是不會拋異常的。@Inject和@Resource沒有提供對應(yīng)的配置，所以必須找到否則會拋異常。

二、 @Autowired和@Inject基本是一樣的，因?yàn)閮烧叨际鞘褂肁utowiredAnnotationBeanPostProcessor來處理 依賴注入。但是@Resource是個例外，它使用的是CommonAnnotationBeanPostProcessor來處理依賴注入。當(dāng)然，兩者 都是BeanPostProcessor。

 
 
    
  
  
  1. @Autowired和@Inject
    2. 
  
  
  2. - 默認(rèn) autowired by type
    3. 
  
  
  3. - 可以 通過@Qualifier 顯式指定 autowired by qualifier name。
    4. 
  
  
  4. - 如果 autowired by type 失?。ㄕ也坏交蛘哒业蕉鄠€實(shí)現(xiàn)），則退化為autowired by field name
    5. 
  
  
  5. 
  
  
  6. @Resource
    7. 
  
  
  7. - 默認(rèn) 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設(shè)計中，Qualified name并不等同于Bean name，后者必須是***的，但是前者類似于tag或者group的作用，對特定的bean進(jìn)行分類?？梢赃_(dá)到getByTag(group)的效果。對 于XML配置的bean，可以通過id屬性指定bean name（如果沒有指定，默認(rèn)使用類名首字母小寫），通過標(biāo)簽指定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會默認(rèn)是用類名首字母小寫(Lamborghini=>lamborghini)。

三、 通過Anotation注入依賴的方式在XML注入方式之前進(jìn)行。如果對同一個bean的依賴同時使用了兩種注入方式，那么XML的優(yōu)先。但是不同擔(dān)心通過Anotation注入的依賴沒法注入XML中配置的bean，依賴注入是在bean的注冊之后進(jìn)行的。

四、目前的autowired by type方式（筆者用的是3.2.3.RELEASE版本），Spring的AutowiredAnnotationBeanPostProcessor 實(shí)現(xiàn)都是有”bug”的，也就是說@Autowired和@Inject都是有坑的（稱之為坑，不稱之為bug是因?yàn)槊菜剖枪室獾?。。）。這是來源于線上 的一個bug，也是這邊文章的寫作原因?，F(xiàn)場如下：

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應(yīng)用的常量定義在如下類中：

 
 
    
  
  
  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，詭異的事情發(fā)生了！

運(yùn)行結(jié)果如下：

 
 
    
  
  
  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. 嚴(yán)重: 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了一下，發(fā)現(xiàn)確實(shí)是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.

關(guān)鍵在這一句：Map

 
 
    
  
  
  1. 嚴(yán)重: 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了一下，發(fā)現(xiàn)跟沒有指定qualifie name是一樣的執(zhí)行路徑。不是指定了bean name了嗎？為什么還是autowired by type呢？仔細(xì)查看了一下才發(fā)現(xiàn)。DefaultListableBeanFactory的doResolveDependency方法對首先對類型做 了區(qū)別：

 
 
    
  
  
  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或者M(jìn)ap，則根據(jù)集合類中元素的類型來進(jìn)行autowired by type（Map使用value的類型）。為什么這么特殊處理呢？原來，Spring是為了達(dá)到這樣的目的：讓你可以一次注入所有符合類型的實(shí)現(xiàn)，也就是 說可以這樣子注入：

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

如果你的car有多個實(shí)現(xiàn)，那么都會注入進(jìn)來，不會再報

 
 
    
  
  
  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.

正常運(yùn)行：

 
 
    
  
  
  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.

當(dāng)然，你如果不指定@Qualifier(“l(fā)anguageChangesMap”)，同時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也可以實(shí)現(xiàn)上面的List接收所有實(shí)現(xiàn)：

 
 
    
  
  
  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.

運(yùn)行的妥妥的：

 
 
    
  
  
  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.

這是因?yàn)锧Resource注解使用的是CommonAnnotationBeanPostProcessor處理器，跟 AutowiredAnnotationBeanPostProcessor不是同一個作者[/偷笑]。這里就不分析了，感興趣的同學(xué)可以自己看代碼研究 一下。

最終結(jié)論如下：

1、@Autowired和@Inject

autowired by type 可以 通過@Qualifier 顯式指定 autowired by qualifier name（非集合類。注意：不是autowired by bean name?。?br /> 如果 autowired by type 失?。ㄕ也坏交蛘哒业蕉鄠€實(shí)現(xiàn)），則退化為autowired by field name（非集合類）

2、@Resource

默認(rèn) 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上，是標(biāo)準(zhǔn)的maven工程，感興趣的同學(xué)可以clone到本地運(yùn)行測試一下。

補(bǔ)充

有同事指出Spring官方文檔上有這么一句話跟我的結(jié)有點(diǎn)沖突：

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注解，其實(shí)也是autowired by type。@Qualifier只是一個限定詞，過濾條件而已。重新跟進(jìn)了一下代碼，發(fā)現(xiàn)確實(shí)是這樣子的。Spring設(shè)計的這個 @Qualifier name 并不等同于 bean name。他有點(diǎn)類似于一個tag。不過如果這個tag是***的化，那么其實(shí)效果上等同于bean name。實(shí)現(xiàn)上，Spring是先getByType，得到list candicates，然后再根據(jù)qualifier name進(jìn)行過濾。

再定義一個蘭博基尼，這里使用@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. 
  
  
                                                當(dāng)前標(biāo)題：JavaSpring各種依賴注入注解的區(qū)別                                                
    
                                                URL鏈接：http://m.5511xx.com/article/ccejcei.html