2. 程式人生 > >Java：學習@Autowired

Java：學習@Autowired

阿新 • • 發佈：2019-01-06

原貼收藏在IT老兵驛站。

前言

使用SpringMVC，現在不可避免要接觸註解，會遇到@Autowired，查詢了google，找到這篇文章，摘錄下來，做一些筆記。為什麼這樣呢？因為至少來說，以當前的理解，自己來寫，不太可能超越這篇文章，我也不想像很多人那樣搞所謂“二次原創”，其實不還是抄襲，只是針對了判定抄襲的規則來做文章，不耍這樣的小聰明，沒有意義。

本篇選取主要的部分翻譯一下，具體的過程可以參考程式碼，本文的英文難度不高，可以嘗試著讀一讀。

正文

1. Overview

Starting with Spring 2.5, the framework introduced a new style of Dependency Injection driven by @Autowired

 Annotations. This annotation allows Spring to resolve and inject collaborating beans into your bean.

In this tutorial, we will look at how to enable autowiring, various ways to wire in beans, making beans optional, resolving bean conflicts using @Qualifier annotation along with potential exception scenarios.

Spring2.5之後，可以使用@Autowired 註解來實現DI（依賴注入），這個詞本身的英文意思就是自動裝配。

2. Enabling @Autowired Annotations

If you are using Java based configuration in your application you can enable annotation-driven injection by using AnnotationConfigApplicationContext to load your spring configuration as below:

1

2

3

@Configuration

@ComponentScan("com.baeldung.autowire.sample")

public class AppConfig {}

As an alternative, in Spring XML, it can be enabled by declaring it in Spring XML files like so: <context:annotation-config/>

想使用註解，現需要配置Spring可以支援註解，有兩種方式，一個是在程式碼中，一個是在XML中，這個涉及到另外一些知識點，作者這裡是假設讀者是知道這些的，不明白的話，需要去查一查。

3. Using @Autowired

Once annotation injection is enabled, autowiring can be used on properties, setters, and constructors.

可以用在屬性、setter方法和構造器上。

3.1. @Autowired on Properties

The annotation can be used directly on properties, therefore eliminating the need for getters and setters:

1

2

3

4

5

6

7

@Component("fooFormatter")

public class FooFormatter {

 

    public String format() {

        return "foo";

    }

}

1

2

3

4

5

6

7

@Component

public class FooService {

     

    @Autowired

    private FooFormatter fooFormatter;

 

}

In the above example, Spring looks for and injects fooFormatter when FooService is created.

如何用在屬性上。

3.2. @Autowired on Setters

The @Autowired annotation can be used on setter methods. In the below example, when the annotation is used on the setter method, the setter method is called with the instance of FooFormatter when FooServiceis created:

1

2

3

4

5

6

7

8

9

public class FooService {

 

    private FooFormatter fooFormatter;

 

    @Autowired

    public void setFooFormatter(FooFormatter fooFormatter) {

            this.fooFormatter = fooFormatter;

    }

}

如何用在方法上。

3.3. @Autowired on Constructors

The @Autowired annotation can also be used on constructors. In the below example, when the annotation is used on a constructor, an instance of FooFormatter is injected as an argument to the constructor when FooService is created:

1

2

3

4

5

6

7

8

9

public class FooService {

 

    private FooFormatter fooFormatter;

 

    @Autowired

    public FooService(FooFormatter fooFormatter) {

        this.fooFormatter = fooFormatter;

    }

}

如何用在構造器方法上。

4. @Autowired and Optional Dependencies

Spring expects @Autowired dependencies to be available when the dependent bean is being constructed. If the framework cannot resolve a bean for wiring, it will throw the below-quoted exception and prevent the Spring container from launching successfully:

1

2

3

4

5

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:

No qualifying bean of type [com.autowire.sample.FooDAO] found for dependency:

expected at least 1 bean which qualifies as autowire candidate for this dependency.

Dependency annotations:

{@org.springframework.beans.factory.annotation.Autowired(required=true)}

To avoid this from happening, a bean can optional be specified as below:

1

2

3

4

5

6

public class FooService {

 

    @Autowired(required = false)

    private FooDAO dataAccessor;

     

}

如果沒有找到響應的bean，又不想系統停止載入，參考上面的寫法。

5. Autowire Disambiguation

By default, Spring resolves @Autowired entries by type. If more than one beans of the same type are available in the container, the framework will throw a fatal exception indicating that more than one bean is available for autowiring.

 @Autowired是根據型別來進行裝備的。但是會存在同一型別內有多個備選bean，這個時候，框架會丟擲一個致命錯誤----這種問題倒是暫時還沒有遇到過，下面講述了三種解決方案。

5.1. Autowiring by @Qualifier

The @Qualifier annotation can be used to hint at and narrow down the required bean:

1

2

3

4

5

6

7

@Component("fooFormatter")

public class FooFormatter implements Formatter {

 

    public String format() {

        return "foo";

    }

}

1

2

3

4

5

6

7

@Component("barFormatter")

public class BarFormatter implements Formatter {

 

    public String format() {

        return "bar";

    }

}

1

2

3

4

5

6

public class FooService {

     

    @Autowired

    private Formatter formatter;

 

}

Since there are two concrete implementations of Formatter available for the Spring container to inject, Spring will throw a NoUniqueBeanDefinitionException exception when constructing the FooService:

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException:

No qualifying bean of type [com.autowire.sample.Formatter] is defined:

expected single matching bean but found 2: barFormatter,fooFormatter

This can be avoided by narrowing the implementation using a @Qualifier annotation:

1

2

3

4

5

6

7

public class FooService {

     

    @Autowired

    @Qualifier("fooFormatter")

    private Formatter formatter;

 

}

By specifying the @Qualifier with the name of the specific implementation, in this case as fooFormatter, we can avoid ambiguity when Spring finds multiple beans of the same type.

Please note that the value of the @Qualifier annotation matches with the name declared in the @Component annotation of our FooFormatter implementation.

使用@Qualifier 註解來標識誰是合格的。

5.2. Autowiring by Custom Qualifier

Spring allows us to create our own @Qualifier annotation. To create a custom Qualifier, define an annotation and provide the @Qualifier annotation within the definition as below:

1

2

3

4

5

6

7

8

9

@Qualifier

@Target({

  ElementType.FIELD, ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})

@Retention(RetentionPolicy.RUNTIME)

public @interface FormatterType {

     

    String value();

 

}

Once defined, the FormatterType can be used within various implementations to specify custom value:

1

2

3

4

5

6

7

8

@FormatterType("Foo")

@Component

public class FooFormatter implements Formatter {

 

    public String format() {

        return "foo";

    }

}

1

2

3

4

5

6

7

8

@FormatterType("Bar")

@Component

public class BarFormatter implements Formatter {

 

    public String format() {

        return "bar";

    }

}

Once the implementations are annotated, the custom Qualifier annotation can be used as below:

1

2

3

4

5

6

7

8

@Component

public class FooService {

     

    @Autowired

    @FormatterType("Foo")

    private Formatter formatter;

     

}

The value specified in the @Target annotation restrict where the qualifier can be used to mark injection points.

In the above code snippet, the qualifier can be used to disambiguate the point where Spring can inject the bean into a field, a method, a type, and a parameter.

5.3. Autowiring by Name

As a fallback Spring uses the bean name as a default qualifier value.

So by defining the bean property name, in this case as fooFormatter, Spring matches that to the FooFormatter implementation and injects that specific implementation when FooService is constructed:

1

2

3

4

5

6

public class FooService {

     

    @Autowired

    private Formatter fooFormatter;

     

}

使用名字來自動裝配。

6. Conclusion

Although both @Qualifier and bean name fallback match can be used to narrow down to a specific bean, autowiring is really all about injection by type and this is how best to use this container feature.

The source code of this tutorial can be found in the GitHub project – this is an Eclipse based project, so it should be easy to import and run as it is.

總結

老外的文章講的真清楚，他們會對讀者負責，很認真地把所有問題講清楚，不像很多國人，哪怕是很多好像挺有名的教授出的書，都是“言簡意賅”，看著好費勁，給人一種高高在上的感覺。當年讀清華嚴蔚敏出的《資料結構》，讀著就非常費勁，後來看大師出的《演算法導論》，反而容易理解，中國人怎麼總就是這麼高傲呢。

參考

https://www.baeldung.com/spring-autowire

https://stackoverflow.com/questions/1018797/can-you-use-autowired-with-static-fields 介紹了靜態域能不能自動裝配

相關推薦

Java：學習@Autowired

原貼收藏在IT老兵驛站。 前言 使用SpringMVC，現在不可避免要接觸註解，會遇到@Autowired，查詢了google，找到這篇文章，摘錄下來，做一些筆記。為什麼這樣呢？因為至少來說，以當前的理解，自己來寫，不太可能超越這篇文章，我也不想像很多人那樣搞所謂“二次原創”，其實不還是抄襲

轉：深入Java集合學習系列：HashSet的實現原理

是否 abstract arc html 源代碼 cat param body static 0.參考文獻 深入Java集合學習系列：HashSet的實現原理 1.HashSet概述： 　　HashSet實現Set接口，由哈希表（實際上是一個HashMap實例）支持。它

轉：25個Java機器學習工具和庫

重點 推薦系統 mine 很多 .sh 分類器 ssi 包括 eve 轉自：http://www.cnblogs.com/data2value/p/5419864.html 本列表總結了25個Java機器學習工具&庫： 1. Weka集成了數據挖掘工作的機器學習算法

java基礎學習總結（二十五）：logback詳解

為什麼使用logback logback大約有以下的一些優點： 核心重寫、測試充分、初始化記憶體載入更小，這一切讓logback效能和log4j相比有諸多倍的提升 logback非常自然地直接實現了slf4j，這個嚴格來說算不上優點，只是這樣，再理解slf4j的前提下會很容易理解

java基礎學習總結（二十四）：slf4j作用及其實現原理

簡單回顧門面模式 slf4j是門面模式的典型應用，因此在講slf4j前，我們先簡單回顧一下門面模式， 門面模式，其核心為外部與一個子系統的通訊必須通過一個統一的外觀物件進行，使得子系統更易於使用。用一張圖來表示門面模式的結構為：   門面模式的核心為Facade即門面

java基礎學習總結（二十三）：什麼要使用AOP

從最基礎的原始程式碼-->使用設計模式（裝飾器模式與代理）-->使用AOP三個層次來講解一下為什麼我們要使用AOP。 原始程式碼的寫法 既然要通過程式碼來演示，那必須要有例子，這裡我的例子為： 有一個介面Dao有insert、delete、update三個方法，在insert

java基礎學習總結（二十二）：Cglib及其基本使用

  Cglib是什麼           Cglib是一個強大的、高效能的程式碼生成包，它廣泛被許多AOP框架使用，為他們提供方法的攔截。下圖是我網上找到的一張Cglib與一些框架和語言的關係： 對此圖總結一下：

java基礎學習總結（二十一）：自己寫一個java.lang.reflect.Proxy代理的實現

     動態代理裡面用到了一個類就是java.lang.reflect.Proxy，這個類是根據代理內容為傳入的介面生成代理用的。本文就自己寫一個Proxy類出來，功能和java.lang.reflect.Proxy一樣，傳入介面、代理內容，生成代理。  

java基礎學習總結（二十）：多執行緒上下文切換

什麼是上下文切換        即使是單核CPU也支援多執行緒執行程式碼，CPU通過給每個執行緒分配CPU時間片來實現這個機制。時間片是CPU分配給各個執行緒的時間，因為時間片非常短，所以CPU通過不停地切換執行緒執行，讓我們感覺多個執行緒時同時執行的，時

java基礎學習總結（十九）：Unsafe與CAS

Unsafe         簡單講一下這個類。Java無法直接訪問底層作業系統，而是通過本地（native）方法來訪問。不過儘管如此，JVM還是開了一個後門，JDK中有一個類Unsafe，它提供了硬體級別的原子操作。     &n

java基礎學習總結（十八）：切勿用普通for迴圈遍歷LinkedList

ArrayList與LinkedList的普通for迴圈遍歷 對於大部分Java程式設計師朋友們來說，可能平時使用得最多的List就是ArrayList，對於ArrayList的遍歷，一般用如下寫法： public static void main(String[] args) {

java基礎學習總結（十七）：Java Socket

一、 什麼是Socket          Socket的概念很簡單，它是網路上執行的兩個程式間雙向通訊的一端，既可以接收請求，也可以傳送請求，利用它可以較為方便地編寫網路上資料的傳遞。 所以簡而言之，Socket就是程序通訊的端點

java基礎學習總結（十六）：程式碼優化

程式碼優化的目標是： 1、減小程式碼的體積 2、提高程式碼執行的效率 程式碼優化細節 （1）儘量指定類、方法的final修飾符     帶有final修飾符的類是不可派生的。在Java核心API中，有許多應用final的例子，例如java.lang.Strin

java基礎學習總結（十五）：抽象類與介面

       抽象類與介面是java語言中對抽象概念進行定義的兩種機制，正是由於他們的存在才賦予java強大的面向物件的能力。他們兩者之間對抽象概念的支援有很大的相似，甚至可以互換，但是也有區別。  一、抽象類    &n

java基礎學習總結（十四）：Enum 型別的使用介紹

一、Enum 型別的介紹    列舉型別（Enumerated Type） 很早就出現在程式語言中，它被用來將一組類似的值包含到一種型別當中。而這種列舉型別的名稱則會被定義成獨一無二的型別描述符，在這一點上和常量的定義相似。不過相比較常量型別，列舉型別可以為宣告的變

java基礎學習總結（十三）：Java異常處理

一、JAVA異常       異常是指不期而至的各種情況，如：檔案找不到、網路連線失敗、非法引數等。異常是一個事件，它發生在程式執行期間，干擾了正常的指令流程。Java通過API中的Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是物件，是Th

java基礎學習總結（十二）：深入理解java內部類

內部類 內部類也是語法糖，是因為它僅僅是一個編譯時的概念，outer.java裡面定義了一個內部類inner，一旦編譯成功，就會生成兩個完全不同的.class檔案了，分別是outer.class和outer$inner.class。所以內部類的名字完全可以和它的外部類名字相同。 內部類分為四

java基礎學習總結（十一）：自動裝箱和自動拆箱

自動拆箱和自動裝箱 Java為每種基本資料型別都提供了對應的包裝器型別。舉個例子： public class TestMain { public static void main(String[] args) { Integer i = 10; } }

java基礎學習總結（十）：可變長度引數以及foreach迴圈原理

一、語法糖        語法糖是一種幾乎每種語言或多或少都提供過的一些方便程式設計師開發程式碼的語法，它只是編譯器實現的一些小把戲罷了，編譯期間以特定的位元組碼或者特定的方式對這些語法做一些處理，開發者就可以直接方便地使用了。這些語法糖雖然不會提供實質性

java基礎學習總結（九）：深入理解Java泛型

一、什麼是泛型         “泛型” 意味著編寫的程式碼可以被不同型別的物件所重用。泛型的提出是為了編寫重用性更好的程式碼。泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。 比如常見的集合類 LinkedList: publi