@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;
 
    @Autowired
    public void setMovieCatalogs(Set<MovieCatalog> movieCatalogs) {
        this.movieCatalogs = movieCatalogs;
    }
 
    // ...
}
public class MovieRecommender {
 
    private Map<String, MovieCatalog> 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包中提供了四個注解，僅用于撰寫注解時使用，他們是：

下面我們開始自己實作一個注解，注解僅支持 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 = https://www.cnblogs.com/javastack/p/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修改靜態欄位的值，但是這種做法非常不推薦，

原文鏈接：https://blog.csdn.net/topdeveloperr/article/details/87971446

著作權宣告：本文為CSDN博主「topEngineerray」的原創文章，遵循CC 4.0 BY-SA著作權協議，轉載請附上原文出處鏈接及本宣告，

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2021最新版)

2.終于靠開源專案弄到 IntelliJ IDEA 激活碼了，真香！

3.阿里 Mock 工具正式開源，干掉市面上所有 Mock 工具！

4.Spring Cloud 2020.0.0 正式發布，全新顛覆性版本！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/291754.html

標籤：Java

上一篇：Gateway網關匹配規則

下一篇：鏈表反轉