Spring中的註解@Autowired實現過程全解(@Autowired 背後的故事)

Posted on by

現在面試，基本上都是面試造火箭🚀，工作擰螺絲🔩。而且是喜歡問一些 Spring 相關的知識點，比如 @Autowired 和 @Resource 之間的區別。魔高一丈，道高一尺。很快不少程序員學會瞭背誦面試題，那我反過來問“Spring 中的註解 @Autowired是如何實現的？”，“說說 @Autowired 的實現原理？”等等，背誦面試題的就露餡瞭。基於此，今天我們來說一說 @Autowired 背後的故事！

前言

使用 Spring 開發時，進行配置主要有兩種方式，一是 xml 的方式，二是 Java config 的方式。Spring 技術自身也在不斷的發展和改變，從當前 Springboot 的火熱程度來看，Java config 的應用是越來越廣泛瞭，在使用 Java config 的過程當中，我們不可避免的會有各種各樣的註解打交道，其中，我們使用最多的註解應該就是 @Autowired 註解瞭。這個註解的功能就是為我們註入一個定義好的 bean。那麼，這個註解除瞭我們常用的屬性註入方式之外還有哪些使用方式呢？它在代碼層面又是怎麼實現的呢？這是本篇文章著重想討論的問題。

@Autowired 註解用法

在分析這個註解的實現原理之前，我們不妨先來回顧一下 @Autowired 註解的用法。

將 @Autowired 註解應用於構造函數，如以下示例所示

`public class MovieRecommender {`
 `private final CustomerPreferenceDao customerPreferenceDao;`
 `@Autowired`
 `public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {`
 `this.customerPreferenceDao = customerPreferenceDao;`
 `}`
 `// ...`
`}`

將 @Autowired 註釋應用於 setter 方法

`public class SimpleMovieLister {`
 `private MovieFinder movieFinder;`
 `@Autowired`
 `public void setMovieFinder(MovieFinder movieFinder) {`
 `this.movieFinder = movieFinder;`
 `}`
 `// ...`
`}`

將 @Autowired 註釋應用於具有任意名稱和多個參數的方法

`public class MovieRecommender {`
 `private MovieCatalog movieCatalog;`
 `private CustomerPreferenceDao customerPreferenceDao;`
 `@Autowired`
 `public void prepare(MovieCatalog movieCatalog,`
 `CustomerPreferenceDao customerPreferenceDao) {`
 `this.movieCatalog = movieCatalog;`
 `this.customerPreferenceDao = customerPreferenceDao;`
 `}`
 `// ...`
`}`

您也可以將 @Autowired 應用於字段，或者將其與構造函數混合，如以下示例所示

`public class MovieRecommender {`
 `private final CustomerPreferenceDao customerPreferenceDao;`
 `@Autowired`
 `private MovieCatalog movieCatalog;`
 `@Autowired`
 `public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {`
 `this.customerPreferenceDao = customerPreferenceDao;`
 `}`
 `// ...`
`}`

直接應用於字段是我們使用的最多的一種方式，但是使用構造方法註入從代碼層面卻是更加好的，具體原因我就不細說瞭，有不懂的可以留言區評論。除此之外，還有以下不太常見的幾種方式。

將 @Autowired 註釋添加到需要該類型數組的字段或方法，則 Spring 會從ApplicationContext 中搜尋符合指定類型的所有 bean，如以下示例所示：

`public class MovieRecommender {`
 `@Autowired`
 `private MovieCatalog[] movieCatalogs;`
 `// ...`
`}`

數組可以，我們可以馬上舉一反三，那容器也可以嗎，答案是肯定的，下面是 set 以及 map 的例子：

`public class MovieRecommender {`
 `private Set<MovieCatalog> movieCatalogs;`
 `private Map<String, MovieCatalog> movieCatalogs;`
 `@Autowired`
 `public void setMovieCatalogs(Set<MovieCatalog> movieCatalogs) {`
 `this.movieCatalogs = movieCatalogs;`
 `}`
 `@Autowired`
 `public void setMovieCatalogs(Map<String, MovieCatalog> movieCatalogs) {`
 `this.movieCatalogs = movieCatalogs;`
 `}`
 `// ...`
`}`

以上就是 @Autowired 註解的主要使用方式，經常使用 Spring 的話應該對其中常用的幾種不會感到陌生。

@Autowired 註解的作用到底是什麼

@Autowired 這個註解我們經常在使用，現在，我想問的是，它的作用到底是什麼呢?

首先，我們從所屬范圍來看，事實上這個註解是屬於 Spring 的容器配置的一個註解，與它同屬容器配置的註解還有：@Required, @Primary, @Qualifier 等等。因此 @Autowired 註解是一個用於容器(container)配置的註解。

其次，我們可以直接從字面意思來看，@autowired 註解來源於英文單詞 autowire，這個單詞的意思是自動裝配的意思。自動裝配又是什麼意思？這個詞語本來的意思是指的一些工業上的用機器代替人口，自動將一些需要完成的組裝任務，或者別的一些任務完成。而在 Spring 的世界當中，自動裝配指的就是使用將 Spring 容器中的 bean 自動的和我們需要這個 bean 的類組裝在一起。

因此，筆者個人對這個註解的作用下的定義就是：將 Spring 容器中的 bean 自動的和我們需要這個 bean 的類組裝在一起協同使用。

接下來，我們就來看一下這個註解背後到底做瞭些什麼工作。

@Autowired 註解是如何實現的

事實上，要回答這個問題必須先弄明白的是 Java 是如何支持註解這樣一個功能的。

Java 的註解實現的核心技術是反射，讓我們通過一些例子以及自己實現一個註解來理解它工作的原理。

例子註解 @Override

@Override 註解的定義如下:

`@Target(ElementType.METHOD)`
`@Retention(RetentionPolicy.SOURCE)`
`public @interface Override {`
`}`

@Override 註解使用 Java 官方提供的註解，它的定義裡面並沒有任何的實現邏輯。註意，所有的註解幾乎都是這樣的，「註解隻能是被看作元數據，它不包含任何業務邏輯」。「註解更像是一個標簽，一個聲明，表面被註釋的這個地方，將具有某種特定的邏輯」。

那麼，問題接踵而至，註解本身不包含任何邏輯，那麼註解的功能是如何實現的呢？答案必然是別的某個地方對這個註解做瞭實現。以 @Override 註解為例，他的功能是重寫一個方法，而他的實現者就是 JVM，Java 虛擬機，Java 虛擬機在字節碼層面實現瞭這個功能。

但是對於開發人員，虛擬機的實現是無法控制的東西，也不能用於自定義註解。所以，如果是我們自己想定義一個獨一無二的註解的話，則我們需要自己為註解寫一個實現邏輯，「換言之，我們需要實現自己註解特定邏輯的功能」。

自己實現一個註解

在自己寫註解之前我們有一些基礎知識需要掌握，那就是我們寫註解這個功能首先是需要 Java 支持的，Java 在 jdk5 當中支持瞭這一功能，「並且在 java.lang.annotation 包中提供瞭四個註解，僅用於編寫註解時使用」，他們是：

註解

作用

「@Documented」

表明是否在java doc中添加Annotation

「@Retention」

定義註釋應保留多長時間，即有效周期。有以下幾種策略：

「RetentionPolicy.SOURCE」 – 在編譯期間丟棄。編譯完成後，這些註釋沒有任何意義，因此它們不會寫入字節碼。示例@Override，@ SuppressWarnings
「RetentionPolicy.CLASS 」– 在類加載期間丟棄。在進行字節碼級後處理時很有用。有點令人驚訝的是，這是默認值。
「RetentionPolicy.RUNTIME」 – 不要丟棄。註釋應該可以在運行時進行反射。這是我們通常用於自定義註釋的內容。

「@Target」

指定可以放置註解的位置。如果不指定，則可以將註解放在任何位置。若我們隻想要其中幾個，則需要定義對應的幾個。

下面是這8個屬性:

ElementType.TYPE（類，接口，枚舉）

ElementType.FIELD（實例變量）

ElementType.METHOD

ElementType.PARAMETER

ElementType.CONSTRUCTOR

ElementType.LOCAL_VARIABLE

ElementType.ANNOTATION_TYPE（在另一個註釋上）

ElementType.PACKAGE（記住package-info.java）

「@Inherited」

控制註解是否對子類產生影響。

下面我們開始自己實現一個註解，註解僅支持 primitives，string和 enumerations 這三種類型。註解的所有屬性都定義為方法，也可以提供默認值。我們先實現一個最簡單的註解。

`import java.lang.annotation.ElementType;`
`import java.lang.annotation.Retention;`
`import java.lang.annotation.RetentionPolicy;`
`import java.lang.annotation.Target;`
`@Target(ElementType.METHOD)`
`@Retention(RetentionPolicy.RUNTIME)`
`public @interface SimpleAnnotation {`
 `String value();`
`}`

上面這個註釋裡面隻定義瞭一個字符傳，它的目標註釋對象是方法，保留策略是在運行期間。下面我們定義一個方法來使用這個註解：

`public class UseAnnotation {`
 `@SimpleAnnotation("testStringValue")`
 `public void testMethod(){`
 `//do something here`
 `}`
`}`

我們在這裡使用瞭這個註解，並把字符串賦值為：testStringValue，到這裡，定義一個註解並使用它，我們就已經全部完成。

簡單的不敢相信。但是，細心一想的話，我們雖然寫瞭一個註解也用瞭它，可是它並沒有產生任何作用啊。也沒有對我們這裡方法產生任何效果啊。是的現在確實是這樣的，原因在於我們前面提到的一點，我們還沒有為這個註解實現它的邏輯，現在我們就來為這個註解實現邏輯。

應該怎麼做呢？我們不妨自己來想一想。首先，我想給標註瞭這個註解的方法或字段實現功能，我們必須得知道，到底有哪些方法，哪些字段使用瞭這個註解吧，因此，這裡我們很容易想到，這裡應該會用到反射。其次，利用反射，我們利用反射拿到這樣目標之後，得為他實現一個邏輯，這個邏輯是這些方法本身邏輯之外的邏輯，這又讓我們想起瞭代理，aop 等知識，我們相當於就是在為這些方法做一個增強。事實上的實現主借的邏輯也大概就是這個思路。梳理一下大致步驟如下:

  • 利用反射機制獲取一個類的 Class 對象
  • 通過這個 class 對象可以去獲取他的每一個方法 method，或字段 Field 等等
  • Method，Field 等類提供瞭類似於 getAnnotation 的方法來獲取這個一個字段的所有註解
  • 拿到註解之後，我們可以判斷這個註解是否是我們要實現的註解，如果是則實現註解邏輯

現在我們來實現一下這個邏輯，代碼如下:

`private static void annotationLogic() {`
 `Class useAnnotationClass = UseAnnotation.class;`
 `for(Method method : useAnnotationClass.getMethods()) {`
 `SimpleAnnotation simpleAnnotation = (SimpleAnnotation)method.getAnnotation(SimpleAnnotation.class);`
 `if(simpleAnnotation != null) {`
 `System.out.println(" Method Name : " + method.getName());`
 `System.out.println(" value : " + simpleAnnotation.value());`
 `System.out.println(" --------------------------- ");`
 `}`
 `}`
`}`

在這裡我們實現的邏輯就是打印幾句話。從上面的實現邏輯我們不能發現，借助於 Java 的反射我們可以直接拿到一個類裡所有的方法，然後再拿到方法上的註解，當然，我們也可以拿到字段上的註解。借助於反射我們可以拿到幾乎任何屬於一個類的東西。

一個簡單的註解我們就實現完瞭。現在我們再回過頭來，看一下 @Autowired 註解是如何實現的。

@Autowired 註解實現邏輯分析

知道瞭上面的知識，我們不難想到，上面的註解雖然簡單，但是 @Autowired 和他最大的區別應該僅僅在於註解的實現邏輯，其他利用反射獲取註解等等步驟應該都是一致的。先來看一下 @Autowired 這個註解在 Spring 的源代碼裡的定義是怎樣的，如下所示：

`package org.springframework.beans.factory.annotation;`
`import java.lang.annotation.Documented;`
`import java.lang.annotation.ElementType;`
`import java.lang.annotation.Retention;`
`import java.lang.annotation.RetentionPolicy;`
`import java.lang.annotation.Target;`
`@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})`
`@Retention(RetentionPolicy.RUNTIME)`
`@Documented`
`public @interface Autowired {`
 `boolean required() default true;`
`}`

閱讀代碼我們可以看到，Autowired 註解可以應用在構造方法，普通方法，參數，字段，以及註解這五種類型的地方，它的保留策略是在運行時。下面，我們不多說直接來看 Spring 對這個註解進行的邏輯實現.

在 Spring 源代碼當中，Autowired 註解位於包 org.springframework.beans.factory.annotation 之中，該包的內容如下：

圖片

經過分析，不難發現 Spring 對 autowire 註解的實現邏輯位於類：AutowiredAnnotationBeanPostProcessor 之中，已在上圖標紅。其中的核心處理代碼如下:

`private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {`
 `LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<>();`
 `Class<?> targetClass = clazz;//需要處理的目標類`
 
 `do {`
 `final LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<>();`
 `/*通過反射獲取該類所有的字段，並遍歷每一個字段，並通過方法findAutowiredAnnotation遍歷每一個字段的所用註解，並如果用autowired修飾瞭，則返回auotowired相關屬性*/` 
 `ReflectionUtils.doWithLocalFields(targetClass, field -> {`
 `AnnotationAttributes ann = findAutowiredAnnotation(field);`
 `if (ann != null) {//校驗autowired註解是否用在瞭static方法上`
 `if (Modifier.isStatic(field.getModifiers())) {`
 `if (logger.isWarnEnabled()) {`
 `logger.warn("Autowired annotation is not supported on static fields: " + field);`
 `}`
 `return;`
 `}//判斷是否指定瞭required`
 `boolean required = determineRequiredStatus(ann);`
 `currElements.add(new AutowiredFieldElement(field, required));`
 `}`
 `});`
 `//和上面一樣的邏輯，但是是通過反射處理類的method`
 `ReflectionUtils.doWithLocalMethods(targetClass, method -> {`
 `Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);`
 `if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {`
 `return;`
 `}`
 `AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);`
 `if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {`
 `if (Modifier.isStatic(method.getModifiers())) {`
 `if (logger.isWarnEnabled()) {`
 `logger.warn("Autowired annotation is not supported on static methods: " + method);`
 `}`
 `return;`
 `}`
 `if (method.getParameterCount() == 0) {`
 `if (logger.isWarnEnabled()) {`
 `logger.warn("Autowired annotation should only be used on methods with parameters: " +`
 `method);`
 `}`
 `}`
 `boolean required = determineRequiredStatus(ann);`
 `PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);`
 `currElements.add(new AutowiredMethodElement(method, required, pd));`
 `}`
 `});`
 `//用@Autowired修飾的註解可能不止一個，因此都加在currElements這個容器裡面，一起處理` 
 `elements.addAll(0, currElements);`
 `targetClass = targetClass.getSuperclass();`
 `}`
 `while (targetClass != null && targetClass != Object.class);`
 `return new InjectionMetadata(clazz, elements);`
 `}`

博主在源代碼裡加瞭註釋，結合註釋就能看懂它做的事情瞭，最後這個方法返回的就是包含所有帶有 autowire 註解修飾的一個 InjectionMetadata 集合。這個類由兩部分組成:

`public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {`
 `this.targetClass = targetClass;`
 `this.injectedElements = elements;`
`}`

一是我們處理的目標類，二就是上述方法獲取到的所以 elements 集合。

有瞭目標類，與所有需要註入的元素集合之後，我們就可以實現 autowired 的依賴註入邏輯瞭，實現的方法如下:

`@Override`
`public PropertyValues postProcessPropertyValues(`
 `PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {`
 `InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);`
 `try {`
 `metadata.inject(bean, beanName, pvs);`
 `}`
 `catch (BeanCreationException ex) {`
 `throw ex;`
 `}`
 `catch (Throwable ex) {`
 `throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);`
 `}`
 `return pvs;`
`}`

它調用的方法是 InjectionMetadata 中定義的 inject 方法，如下

`public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {`
 `Collection<InjectedElement> checkedElements = this.checkedElements;`
 `Collection<InjectedElement> elementsToIterate =`
 `(checkedElements != null ? checkedElements : this.injectedElements);`
 `if (!elementsToIterate.isEmpty()) {`
 `for (InjectedElement element : elementsToIterate) {`
 `if (logger.isTraceEnabled()) {`
 `logger.trace("Processing injected element of bean '" + beanName + "': " + element);`
 `}`
 `element.inject(target, beanName, pvs);`
 `}`
 `}`
`}`

其邏輯就是遍歷，然後調用 inject 方法，inject 方法其實現邏輯如下:

`/**`
 `* Either this or {@link #getResourceToInject} needs to be overridden.`
 `*/`
`protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)`
 `throws Throwable {`
 `if (this.isField) {`
 `Field field = (Field) this.member;`
 `ReflectionUtils.makeAccessible(field);`
 `field.set(target, getResourceToInject(target, requestingBeanName));`
 `}`
 `else {`
 `if (checkPropertySkipping(pvs)) {`
 `return;`
 `}`
 `try {`
 `Method method = (Method) this.member;`
 `ReflectionUtils.makeAccessible(method);`
 `method.invoke(target, getResourceToInject(target, requestingBeanName));`
 `}`
 `catch (InvocationTargetException ex) {`
 `throw ex.getTargetException();`
 `}`
 `}`
`}`

在這裡的代碼當中我們也可以看到，是 inject 也使用瞭反射技術並且依然是分成字段和方法去處理的。在代碼裡面也調用瞭 makeAccessible 這樣的可以稱之為暴力破解的方法，但是反射技術本就是為框架等用途設計的，這也無可厚非。

對於字段的話，本質上就是去 set 這個字段的值，即對對象進行實例化和賦值，例如下面代碼:

`@Autowired`
`ObjectTest objectTest;`

那麼在這裡實現的就相當於給這個 objecTest 引用賦值瞭。

對於方法的話，本質就是去調用這個方法，因此這裡調用的是 method.invoke。

getResourceToInject 方法的參數就是要註入的 bean 的名字，這個方法的功能就是根據這個 bean 的名字去拿到它。

以上，就是 @Autowire 註解實現邏輯的全部分析。結合源代碼再看一遍的話，會更加清楚一點。下面是 Spring 容器如何實現 @AutoWired 自動註入的過程的圖:

圖片

總結起來一句話：使用 @Autowired 註入的 bean 對於目標類來說，從代碼結構上來講也就是一個普通的成員變量，@Autowired 和 Spring 一起工作，通過反射為這個成員變量賦值，也就是將其賦為期望的類實例。

衍生問題

註解的有效周期是什麼？

各種註釋之間的第一個主要區別是，它們是在編譯時使用，然後被丟棄（如@Override），還是被放在編譯的類文件中，並在運行時可用（如 Spring 的@Component）。這是由註釋的“@Retention”策略決定的。如果您正在編寫自己的註釋，則需要決定該註釋在運行時（可能用於自動配置）還是僅在編譯時（用於檢查或代碼生成）有用。

當用註釋編譯代碼時，編譯器看到註釋就像看到源元素上的其他修飾符一樣，比如訪問修飾符（public / private）。當遇到註釋時，它運行一個註釋處理器，就像一個插件類，表示對特定的註釋感興趣。註釋處理器通常使用反射API來檢查正在編譯的元素，並且可以簡單地對它們執行檢查、修改它們或生成要編譯的新代碼。@Override 是一個示例；它使用反射 API 來確保能夠在其中一個超類中找到方法簽名的匹配，如果不能，則使用 @Override 會導致編譯錯誤。

註入的 bean 和用它的 bean 的關系是如何維護的？

無論以何種方式註入，註入的 bean 就相當於類中的一個普通對象應用，這是它的實例化是 spring 去容器中找符合的 bean 進行實例化，並註入到類當中的。他們之間的關系就是普通的一個對象持有另一個對象引用的關系。隻是這些對象都是 Spring 當中的 bean 而已。

為什麼註入的 bean 不能被定義為 static 的？

從設計的角度來說 ，使用靜態字段會鼓勵使用靜態方法。靜態方法是 evil 的。依賴註入的主要目的是讓容器為您創建對象並進行連接。而且，它使測試更加容易。

一旦開始使用靜態方法，您就不再需要創建對象的實例，並且測試變得更加困難。同樣，您不能創建給定類的多個實例，每個實例都註入不同的依賴項（因為該字段是隱式共享的，並且會創建全局狀態）。

靜態變量不是 Object 的屬性，而是 Class 的屬性。Spring 的 autowire 是在對象上完成的，這樣使得設計很幹凈。 在 Spring 當中我們也可以將 bean 對象定義為單例，這樣就能從功能上實現與靜態定義相同的目的。

但是從純粹技術的層面，我們可以這樣做：

將 @Autowired 可以與 setter 方法一起使用，然後可以讓 setter 修改靜態字段的值。但是這種做法非常不推薦。

到此這篇關於Spring中的註解@Autowired實現過程全解的文章就介紹到這瞭,更多相關Spring註解@Autowired內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

到此這篇關於Spring中的註解@Autowired實現過程全解(@Autowired 背後的故事)的文章就介紹到這瞭,更多相關Spring註解@Autowired內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：