詳解Java Spring各種依賴注入註解的區別

註解注入顧名思義就是通過註解來實現注入，Spring和注入相關的常見註解有Autowired、Resource、Qualifier、Service、Controller、Repository、Component。

Autowired是自動注入，自動從spring的上下文找到合適的bean來注入

Resource用來指定名稱注入

Qualifier和Autowired配合使用，指定bean的名稱
Service，Controller，Repository分別標記類是Service層類，Controller層類，數據存儲層的類，spring掃描註解配置時，會標記這些類要生成bean。

Component是一種泛指，標記類是組件，spring掃描註解配置時，會標記這些類要生成bean。

Spring對於Bean的依賴注入，支持多種註解方式：

 @Resource javax.annotation JSR250 (Common Annotations for Java) @Inject javax.inject JSR330 (Dependency Injection for Java) @Autowired org.springframework.bean.factory Spring

直觀上看起來，@Autowired是Spring提供的註解，其他幾個都是JDK本身內建的註解，Spring對這些註解也進行了支持。但是使用起來這三者到底有什麼區別呢？筆者經過方法的測試，發現一些有意思的特性。

區別總結如下：

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

二、 @Autowired和@Inject基本是一樣的，因為兩者都是使用AutowiredAnnotationBeanPostProcessor來處理依賴注入。但是@Resource是個例外，它使用的是CommonAnnotationBeanPostProcessor來處理依賴注入。當然，兩者都是BeanPostProcessor。

 @Autowired和@Inject - 默認autowired by type - 可以通過@Qualifier 顯式指定autowired by qualifier name。 - 如果autowired by type 失敗（找不到或者找到多個實現），則退化為autowired by field name @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了。

TIPS Qualified name VS Bean name

在Spring設計中，Qualified name並不等同於Bean name，後者必須是唯一的，但是前者類似於tag或者group的作用，對特定的bean進行分類。可以達到getByTag(group)的效果。對於XML配置的bean，可以通過id屬性指定bean name（如果沒有指定，默認使用類名首字母小寫），通過標籤指定qualifier name：

 <bean id="lamborghini"> <qualifier value="luxury"/> <!-- inject any dependencies required by this bean --> </bean>

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

 @Component("lamborghini") @Qualifier("luxury") public class Lamborghini implements Car { }

或者

@Component @Named("lamborghini") @Qualifier("luxury") public class Lamborghini implements Car { }

同樣，如果沒有指定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中有如下定義：

 <xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd"> <context:annotation-config /> <context:component-scan base-package="me.arganzheng.study" /> <util:constant id="en" static-field="me.arganzheng.study.spring.autowired.Constants.Language.EN" /> <util:constant id="ja" static-field="me.arganzheng.study.spring.autowired.Constants.Language.JP" /> <util:constant id="ind" static-field="me.arganzheng.study.spring.autowired.Constants.Language.IND" /> <util:constant id="pt" static-field="me.arganzheng.study.spring.autowired.Constants.Language.PT" /> <util:constant id="th" static-field="me.arganzheng.study.spring.autowired.Constants.Language.TH" /> <util:constant id="ar" static-field="me.arganzheng.study.spring.autowired.Constants.Language.AR" /> <util:constant id="en-rIn" static-field="me.arganzheng.study.spring.autowired.Constants.Language.EN_RIN" /> <util:map id="languageChangesMap" key-type="java.lang.String" value-type="java.lang.String"> <entry key="pt" value="pt" /> <entry key="br" value="pt" /> <entry key="jp" value="ja" /> <entry key="ja" value="ja" /> <entry key="ind" value="ind" /> <entry key="id" value="ind" /> <entry key="en-rin" value="en-rIn" /> <entry key="in" value="en-rIn" /> <entry key="en" value="en" /> <entry key="gb" value="en" /> <entry key="th" value="th" /> <entry key="ar" value="ar" /> <entry key="eg" value="ar" /> </util:map> </beans>

其中static-field應用的常量定義在如下類中：

 package me.arganzheng.study.spring.autowired; public interface Constants { public interface Language { public static final String EN = "CommonConstants.LANG_ENGLISH"; public static final String JP = "CommonConstants.LANG_JAPANESE"; public static final String IND = "CommonConstants.LANG_INDONESIAN"; public static final String PT = "CommonConstants.LANG_PORTUGUESE"; public static final String TH = "CommonConstants.LANG_THAI"; public static final String EN_RIN = "CommonConstants.LANG_ENGLISH_INDIA"; public static final String AR = "CommonConstants.LANG_Arabic"; } }

然後如果我們在代碼中如下聲明依賴：

 public class AutowiredTest extends BaseSpringTestCase { @Autowired private Map<String, String> languageChangesMap; @Test public void testAutowired() { notNull(languageChangesMap); System.out.println(languageChangesMap.getClass().getSimpleName()); System.out.println(languageChangesMap); } }

Guess what，詭異的事情發生了！

運行結果如下：

 LinkedHashMap {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}

也就是說Map

嚴重: Caught exception while allowing TestExecutionListener

 [org.springframework.test.context.support.DependencyInjectionTestExecutionListener@5c51ee0a] to prepare test instance [me.arganzheng.study.spring.autowired.AutowiredTest@6e301e0] 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)} ... 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)} at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:986) at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:843) at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:768) at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:486) ... 28 more

debug了一下，發現確實是Spring的一個bug。在DefaultListableBeanFactory的這個方法出問題了：

 protected Object doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { ... else if (Map.class.isAssignableFrom(type) && type.isInterface()) { Class<?> keyType = descriptor.getMapKeyType(); if (keyType == null || !String.class.isAssignableFrom(keyType)) { if (descriptor.isRequired()) { throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() + "] must be assignable to [java.lang.String]"); } return null; } Class<?> valueType = descriptor.getMapValueType(); if (valueType == null) { if (descriptor.isRequired()) { throw new FatalBeanException("No value type declared for map [" + type.getName() + "]"); } return null; } Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor); } return null; } if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } return matchingBeans; } ... }

關鍵在這一句：Map

嚴重: Caught exception while allowing TestExecutionListener

 [org.springframework.test.context.support.DependencyInjectionTestExecutionListener@9476189] to prepare test instance [me.arganzheng.study.spring.autowired.AutowiredTest@2d546e21] ... 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)} at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:986) at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:843) at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:768) at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:486) ... 28 more

debug了一下，發現跟沒有指定qualifie name是一樣的執行路徑。不是指定了bean name了嗎？為什麼還是autowired by type呢？仔細查看了一下才發現。 DefaultListableBeanFactory的doResolveDependency方法對首先對類型做了區別：

 protected Object doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor); if (value != null) { if (value instanceof String) { String strVal = resolveEmbeddedValue((String) value); BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null); value = evaluateBeanDefinitionString(strVal, bd); } TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter()); return (descriptor.getField() != null ? converter.convertIfNecessary(value, type, descriptor.getField()) : converter.convertIfNecessary(value, type, descriptor.getMethodParameter())); } if (type.isArray()) { Class<?> componentType = type.getComponentType(); Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor); } return null; } if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter()); return converter.convertIfNecessary(matchingBeans.values(), type); } else if (Collection.class.isAssignableFrom(type) && type.isInterface()) { Class<?> elementType = descriptor.getCollectionType(); if (elementType == null) { if (descriptor.isRequired()) { throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]"); } return null; } Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor); } return null; } if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter()); return converter.convertIfNecessary(matchingBeans.values(), type); } else if (Map.class.isAssignableFrom(type) && type.isInterface()) { Class<?> keyType = descriptor.getMapKeyType(); if (keyType == null || !String.class.isAssignableFrom(keyType)) { if (descriptor.isRequired()) { throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() + "] must be assignable to [java.lang.String]"); } return null; } Class<?> valueType = descriptor.getMapValueType(); if (valueType == null) { if (descriptor.isRequired()) { throw new FatalBeanException("No value type declared for map [" + type.getName() + "]"); } return null; } Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor); } return null; } if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } return matchingBeans; } else { Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(type, "", descriptor); } return null; } if (matchingBeans.size() > 1) { String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor); if (primaryBeanName == null) { throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet()); } if (autowiredBeanNames != null) { autowiredBeanNames.add(primaryBeanName); } return matchingBeans.get(primaryBeanName); } // We have exactly one match. Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next(); if (autowiredBeanNames != null) { autowiredBeanNames.add(entry.getKey()); } return entry.getValue(); } }

如果是Array，Collection或者Map，則根據集合類中元素的類型來進行autowired by type（Map使用value的類型）。為什麼這麼特殊處理呢？原來，Spring是為了達到這樣的目的：讓你可以一次注入所有符合類型的實現，也就是說可以這樣子注入：

@Autowired
private List<Car> cars;

如果你的car有多個實現，那麼都會注入進來，不會再報

org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [me.arganzheng.study.spring.autowired.Car] is defined: expected single matching bean but found 2: [audi, toyota].

然而，上面的情況如果你用@Resource則不會有這個問題：

 public class AutowiredTest extends BaseSpringTestCase { @Resource @Qualifier("languageChangesMap") private Map<String, String> languageChangesMap; @Test public void testAutowired() { assertNotNull(languageChangesMap); System.out.println(languageChangesMap.getClass().getSimpleName()); System.out.println(languageChangesMap); } }

正常運行：

 LinkedHashMap {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}

當然，你如果不指定@Qualifier(“languageChangesMap”)，同時field name不是languageChangesMap，那麼還是一樣報錯的。

 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=)} at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:986) at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:843) at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:768) at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:438) at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:416) at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor$ResourceElement.getResourceToInject(CommonAnnotationBeanPostProcessor.java:550) at org.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(InjectionMetadata.java:150) at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:87) at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessPropertyValues(CommonAnnotationBeanPostProcessor.java:303) ... 26 more

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

 public class AutowiredTest extends BaseSpringTestCase { @Resource @Qualifier("languageChangesMap") private Map<String, String> languageChangesMap; @Resource private List<Car> cars; @Test public void testAutowired() { assertNotNull(languageChangesMap); System.out.println(languageChangesMap.getClass().getSimpleName()); System.out.println(languageChangesMap); assertNotNull(cars); System.out.println(cars.getClass().getSimpleName()); System.out.println(cars); } }

運行的妥妥的：

 LinkedHashMap {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} ArrayList

[me.arganzheng.study.spring.autowired.Audi@579584da, me.arganzheng.study.spring.autowired.Toyota@19453122]
這是因為@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指定：

 package me.arganzheng.study.spring.autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Component; @Component @Qualifier("luxury") public class Lamborghini implements Car { }

再定義一個勞斯萊斯，這裡故意用@Named指定：

 package me.arganzheng.study.spring.autowired; import javax.inject.Named; import org.springframework.stereotype.Component; @Component @Named("luxury") public class RollsRoyce implements Car { }

測試一下注入定義的豪華車：

 package me.arganzheng.study.spring.autowired; import static junit.framework.Assert.assertNotNull; import java.util.List; import me.arganzheng.study.BaseSpringTestCase; import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; /** * * @author zhengzhibin * */ public class AutowiredTest extends BaseSpringTestCase { @Autowired @Qualifier("luxury") private List<Car> luxuryCars; @Test public void testAutowired() { assertNotNull(luxuryCars); System.out.println(luxuryCars.getClass().getSimpleName()); System.out.println(luxuryCars); } }

運行結果如下：

 ArrayList [me.arganzheng.study.spring.autowired.Lamborghini@66b875e1, me.arganzheng.study.spring.autowired.RollsRoyce@58433b76]

補充：Autowiring modes

Spring支持四種autowire模式，當使用XML配置方式時，你可以通過autowire屬性指定。

 no. (Default) No autowiring. Bean references must be defined via a ref element. Changing the default setting is not recommended for larger deployments, because specifying collaborators explicitly gives greater control and clarity. To some extent, it documents the structure of a system. byName. Autowiring by property name. Spring looks for a bean with the same name as the property that needs to be autowired. For example, if a bean definition is set to autowire by name, and it contains a master property (that is, it has a setMaster(..) method), Spring looks for a bean definition named master, and uses it to set the property. byType. Allows a property to be autowired if exactly one bean of the property type exists in the container. If more than one exists, a fatal exception is thrown, which indicates that you may not use byType autowiring for that bean. If there are no matching beans, nothing happens; the property is not set. constructor. Analogous to byType, but applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised.

如果使用@Autowired、@Inject或者@Resource註解的時候，則稍微複雜一些，會有一個失敗退化過程，並且引入了Qualifier。不過基本原理是一樣。