什么是依賴注入

依賴注入是一個(gè)過程，舉個(gè)例子：

public class A {
    private B b;
    // 省略 getter 和 setter
    // 省略構(gòu)造方法
}

現(xiàn)在 A 類 是依賴 B 類的，沒有 B，A 什么都不是。Spring IoC 容器創(chuàng)建好 B 的實(shí)例對(duì)象后并賦值給 A 對(duì)象中的 b 屬性（成員變量）的過程，就是所謂的「依賴注入」。

當(dāng)然，這也是所謂的控制反轉(zhuǎn)了，對(duì)象 b 的創(chuàng)建不是我們手動(dòng) new 創(chuàng)建的，而是 Spring IoC 容器創(chuàng)建的。

使用 DI 原則，可以讓代碼更加簡潔，當(dāng)對(duì)象提供其依賴項(xiàng)時(shí)，解耦也更加有效。依賴項(xiàng) B 注入給 A 的實(shí)例對(duì)象，A 的實(shí)例對(duì)象是不會(huì)查找它的依賴項(xiàng) B 的，也不知道依賴項(xiàng) B 的位置。

依賴注入主要有兩種實(shí)現(xiàn)方式：基于構(gòu)造方法的依賴注入和基于 Setter 的依賴注入。

基于構(gòu)造方法的依賴注入

基于構(gòu)造方法的 DI 是通過 Spring IoC 容器調(diào)用帶有許多參數(shù)的構(gòu)造方法來完成的，每個(gè)參數(shù)表示一個(gè)依賴項(xiàng)。這與上一篇中調(diào)用具有特定參數(shù)的靜態(tài)工廠方法來構(gòu)造 Bean 是幾乎等價(jià)的。

public class Vehicle {
    // Vehicle 依賴于 Producer 對(duì)象，或者說 Vehicle 持有一個(gè) Producer 依賴項(xiàng)
    private final Producer producer;
    // 構(gòu)造方法，讓 Spring IoC 容器能夠注入 Producer 對(duì)象給 Vehicle 對(duì)象
    public Vehicle(Producer producer) {
        this.producer = producer;
    }
}

注意，這個(gè) Vehicle 類就只是一個(gè)普通的 Java Bean，或者說 POJO，沒什么特別之處，最普通不過的類了，沒有繼承或者實(shí)現(xiàn) Spring 指定的任意類。

構(gòu)造方法中參數(shù)的解析

Spring IoC 是通過構(gòu)造方法參數(shù)的解析來匹配需要注入的依賴項(xiàng)。換句話說，解析實(shí)際上就是通過匹配參數(shù)的類型，來確定注入什么依賴項(xiàng)。

如果構(gòu)造方法的參數(shù)中沒有存在潛在的歧義，那么在 Bean 被實(shí)例化的時(shí)候，構(gòu)造方法中參數(shù)的順序和實(shí)例化時(shí)進(jìn)行賦值是一樣的。

package cn.god23bin.demo.model;
public class A {
    private B b;
    private C c;
    public A(B b, C c) {
        this.b = b;
        this.c = c;
    }
}

單獨(dú)寫這些類，是完成不了依賴注入的，這時(shí)候需要配置元數(shù)據(jù)了，讓它與 Java 類相結(jié)合，才能發(fā)揮 Spring IoC 的作用。

現(xiàn)在假設(shè) B 和 C 是沒有任何繼承上的關(guān)聯(lián)，也沒有任何潛在的歧義，那么我們?cè)谂渲迷獢?shù)據(jù)中的配置是正常的，需要使用到 <constructor-arg/> 標(biāo)簽，該標(biāo)簽只需有一個(gè) ref 屬性，即引用（reference），指明 A 的構(gòu)造方法的參數(shù)為 B 和 C，如下：

<beans>
	<bean id="a" class="cn.god23bin.demo.model.A">
		<constructor-arg ref="b"/>
		<constructor-arg ref="c"/>
	</bean>
	<bean id="b" class="cn.god23bin.demo.model.B"/>
	<bean id="c" class="cn.god23bin.demo.model.C"/>
</beans>

我們知道，B 和 C 是屬于引用類型，類型是確切的，所以直接使用 ref 屬性。

如果是基本數(shù)據(jù)類型，那么賦值時(shí)，就可能會(huì)有歧義，Spring 不能確定這個(gè)值的類型，比如一個(gè)基本數(shù)據(jù)類型的值是 true，這時(shí)候歧義就出現(xiàn)了，它是布爾類型還是字符串類型呢？這就需要由我們來告訴 Spring 了，就需要使用 type 和 value 屬性來指定。

比如：

package cn.god23bin.demo.model;
public class D {
    private final int money;
    private final String power;
    public D(int money, String power) {
        this.money = money;
        this.power = power;
    }
}

<bean id="d" class="cn.god23bin.demo.model.D">
	<constructor-arg type="int" value="25000000"/>
	<constructor-arg type="java.lang.String" value="25"/>
</bean>

當(dāng)然，除了使用 type 指定基本數(shù)據(jù)類型，還有兩個(gè)屬性可以解決歧義，分別是 index 和 name 屬性。

index 屬性：

使用 index 屬性指定構(gòu)造方法參數(shù)的下標(biāo)，下標(biāo)是從 0 開始的，來解決參數(shù)類型出現(xiàn)歧義的情況。

<bean id="d" class="cn.god23bin.demo.model.D">
	<constructor-arg index="0" value="25000000"/>
	<constructor-arg index="1" value="25"/>
</bean>

name 屬性：

使用 name 屬性指定構(gòu)造方法參數(shù)的名稱來解決歧義。

<bean id="d" class="cn.god23bin.demo.model.D">
	<constructor-arg name="money" value="25000000"/>
	<constructor-arg name="power" value="25"/>
</bean>

基于 Setter 的依賴注入

基于 Setter 的 DI，是在 Spring IoC 容器調(diào)用了 Bean 的無參構(gòu)造方法或者無參的靜態(tài)工廠方法實(shí)例化了 Bean 之后，再來調(diào)用 Bean 的 Setter 方法來實(shí)現(xiàn)的。

下面這個(gè)依舊是普通的 Java Bean，當(dāng)然你加上相關(guān)業(yè)務(wù)邏輯，就不是純粹的 Java Bean 了，不過 Spring 依舊能夠管理這種對(duì)象。

Vehicle：

public class Vehicle {
    // Vehicle 持有的 Producer 依賴項(xiàng)
    private Producer pro;
    // 同理
    private Author aut;
    // 同理
    private int money;
    // setter 方法，可以讓 Spring IoC 容器調(diào)用注入 Producer 對(duì)象
    public void setProducer(Producer pro) {
        this.pro = pro;
    }
    // 同理
    public void setAut(Author aut) {
        this.aut = aut;
    }
    // 同理
    public void setMoney(int money) {
        this.money = money
    }
    // 業(yè)務(wù)邏輯，有關(guān) Producer 的...
}

對(duì)應(yīng)的配置元數(shù)據(jù)：

<bean id="vehicle" class="cn.god23bin.demo.model.Vehicle">
    <!-- 使用 property 標(biāo)簽的 ref 屬性注入引用類型的依賴項(xiàng) -->
    <property name="pro" ref="producer"/>
    <!-- 使用內(nèi)嵌 ref 標(biāo)簽 注入 -->
    <property name="aut">
    	<ref bean="author"/>
    </property>
    <property name="money" value="255"/>
</bean>
<bean id="producer" class="cn.god23bin.demo.model.Producer"/>
<bean id="author" class="cn.god23bin.demo.model.Author"/>

Spring IoC 容器（ApplicationContext）支持基于構(gòu)造方法的 DI 和基于 Setter 的 DI，也支持使用構(gòu)造方法注入了一部分依賴項(xiàng)后，再使用 Setter 的方式注入其他的依賴項(xiàng)。

我們可以通過配置一個(gè) BeanDefinition 和 PropertyEditor 來實(shí)現(xiàn)這些屬性的注入。但是，我們基本不會(huì)這樣用，而是使用 XML 的 Bean 定義，使用注解的 Bean 定義（比如 @Component，@Controller 等），又或者使用 @Bean 這種基于 Java 配置類的方式（@Configuration）來定義。

實(shí)際上，這些最終都會(huì)轉(zhuǎn)成 BeanDefinition 對(duì)象的并被 Spring IoC 使用。

選擇哪個(gè) DI 方式

在代碼的編寫中，選擇使用構(gòu)造方法注入還是使用 Setter 注入呢？

官網(wǎng)上是這么說的：

Since you can mix constructor-based and setter-based DI, it is a good rule of thumb to use constructors for mandatory dependencies and setter methods or configuration methods for optional dependencies. Note that use of the @Autowired annotation on a setter method can be used to make the property be a required dependency; however, constructor injection with programmatic validation of arguments is preferable.

The Spring team generally advocates constructor injection, as it lets you implement application components as immutable objects and ensures that required dependencies are not null. Furthermore, constructor-injected components are always returned to the client (calling) code in a fully initialized state. As a side note, a large number of constructor arguments is a bad code smell, implying that the class likely has too many responsibilities and should be refactored to better address proper separation of concerns.

Setter injection should primarily only be used for optional dependencies that can be assigned reasonable default values within the class. Otherwise, not-null checks must be performed everywhere the code uses the dependency. One benefit of setter injection is that setter methods make objects of that class amenable to reconfiguration or re-injection later. Management through JMX MBeans is therefore a compelling use case for setter injection.

Use the DI style that makes the most sense for a particular class. Sometimes, when dealing with third-party classes for which you do not have the source, the choice is made for you. For example, if a third-party class does not expose any setter methods, then constructor injection may be the only available form of DI.

簡而言之，Spring 團(tuán)隊(duì)是推薦用構(gòu)造方法來完成 DI 的。

• 對(duì)于強(qiáng)依賴項(xiàng)，直接用基于構(gòu)造方法的 DI，這種注入方式能夠保證注入的 Bean 對(duì)象不可變，并且確保需要的依賴不為空。此外，構(gòu)造方法注入的依賴總是能夠在返回**客戶端（調(diào)用方）**的時(shí)候保證完全初始化的狀態(tài)。
• 對(duì)于可選的弱依賴項(xiàng)，使用基于 Setter 的 DI。當(dāng)使用 @Autowired 注解，并將注解用到 Setter 方法上的話，那么這個(gè) Setter 設(shè)置的屬性就變成強(qiáng)依賴了。

對(duì)于構(gòu)造方法進(jìn)行 DI ，其中：

• 依賴不可變：其實(shí)說的就是 final 關(guān)鍵字。
• 依賴不為空：省去了我們對(duì)注入的 Bean 的檢查，當(dāng)要實(shí)例化 Bean 的時(shí)候，由于自己實(shí)現(xiàn)了有參數(shù)的構(gòu)造方法，所以不會(huì)調(diào)用默認(rèn)構(gòu)造方法，那么就需要 Spring IoC 容器傳入所需要的參數(shù)給有參構(gòu)造方法，所以就兩種情況，有該類型的參數(shù)傳入，那么 OK ；無該類型的參數(shù)，那么報(bào)錯(cuò)。
• 完全初始化的狀態(tài)：這個(gè)可以跟上面的依賴不為空結(jié)合起來，向構(gòu)造方法傳參之前，要確保注入的內(nèi)容不為空，那么肯定要調(diào)用依賴對(duì)象的構(gòu)造方法完成實(shí)例化。而在 Java 類加載實(shí)例化的過程中，構(gòu)造方法是最后一步才執(zhí)行的，所以返回來的實(shí)例化對(duì)象都是完全初始化之后的狀態(tài)。

依賴的處理過程

Spring IoC 容器按如下方式執(zhí)行 Bean 的依賴處理（Dependency Resolution Process，個(gè)人認(rèn)為把 Resolution 理解成處理，解決等意思比較好）。

• 根據(jù)配置元數(shù)據(jù)的內(nèi)容，ApplicationContext 被創(chuàng)建和初始化。這個(gè)配置元數(shù)據(jù)是用來描述所有 Bean 的，它可以是 XML、Java 代碼或注解。
• 對(duì)于每個(gè) Bean 來說，它的依賴是以屬性、構(gòu)造方法參數(shù)或靜態(tài)工廠方法的參數(shù)（如果你用它代替構(gòu)造方法）的形式表達(dá)的。在 Spring IoC 創(chuàng)建 Bean 的時(shí)候，這些依賴會(huì)被提供給需要的 Bean。
• 每個(gè)屬性或構(gòu)造方法參數(shù)都是要設(shè)置的值的實(shí)際定義，或?qū)θ萜髦辛硪粋€(gè) Bean 的引用。
• 每個(gè)作為值的屬性或構(gòu)造方法參數(shù)都會(huì)從其指定格式轉(zhuǎn)換為該屬性或構(gòu)造方法參數(shù)的實(shí)際類型。默認(rèn)情況下，Spring 可以將以字符串格式提供的值轉(zhuǎn)換為所有內(nèi)置類型，如 int、long、String、boolean 等等。

當(dāng) Spring IoC 容器被創(chuàng)建時(shí)，Spring IoC 容器一開始就會(huì)校驗(yàn)每個(gè) Bean 的配置。在創(chuàng)建 Bean 之前，Bean 的屬性本身不會(huì)被設(shè)置。

而且當(dāng)容器被創(chuàng)建時(shí)，那些具有單例作用域的 Bean 也默認(rèn)會(huì)被創(chuàng)建。對(duì)于其他情況的 Bean，只有在被請(qǐng)求時(shí)才會(huì)創(chuàng)建。

一個(gè) Bean 的創(chuàng)建是有可能導(dǎo)致一堆 Bean 被創(chuàng)建，這一堆的 Bean 被稱為 Bean 圖（a graph of beans），因?yàn)?Bean 與 Bean 之間可能存在相互依賴，如同社會(huì)中的人一樣，都有相關(guān)的聯(lián)系，所以形成 Bean 圖。

Bean 作用域在進(jìn)行 Bean 定義的時(shí)候可以進(jìn)行定義，使用 scope 屬性即可定義 Bean 的作用域。

循環(huán)依賴

當(dāng)你使用構(gòu)造函數(shù)注入的時(shí)候，某種情況下可能產(chǎn)生一個(gè)無法解決的循環(huán)依賴問題。那什么是循環(huán)依賴？

舉個(gè)例子：

public class A {
    private B b;
    public A(B b) {
        this.b = b;
    }
}

public class B {
    private A a;
    public B(A a){
        this.a = a;
    }
}

如上所示，A 類通過構(gòu)造方法注入需要 B 類的對(duì)象，而 B 類也通過構(gòu)造方法注入 A 類的一個(gè)對(duì)象，這種情況就是所謂的循環(huán)依賴，A 和 B 之間相互依賴。

A 和 B 之間的循環(huán)依賴關(guān)系會(huì)迫使其中一個(gè) Bean 在未完全初始化之前，被注入到另一個(gè) Bean 中。

這時(shí)候，Spring IoC 容器會(huì)在運(yùn)行時(shí)檢測到這種循環(huán)的引用，并拋出一個(gè) BeanCurrentlyInCreationException。

有一種解決方案就是：修改 A 類或者 B 類的源代碼，使其通過 Setter 方式注入依賴項(xiàng)。

當(dāng)然，一般情況下，我們可以完全相信 Spring，Spring 會(huì)在容器加載時(shí)檢測配置問題，如檢查引用不存在的 Bean 或循環(huán)依賴等。它會(huì)盡量晚地設(shè)置 Bean 的屬性以及處理依賴的關(guān)系。

假設(shè)當(dāng)你請(qǐng)求一個(gè)對(duì)象時(shí)，如果在創(chuàng)建該對(duì)象或其依賴關(guān)系時(shí)出現(xiàn)問題，已經(jīng)正確加載的 Spring 容器就會(huì)產(chǎn)生異常。所以，這意味著我們需要提前發(fā)現(xiàn)這些問題。

默認(rèn)情況下，ApplicationContext 會(huì)預(yù)先實(shí)例化單例 Bean，所以在創(chuàng)建 Spring IoC 容器時(shí)會(huì)花費(fèi)一些時(shí)間和內(nèi)存。但好處是可以在容器創(chuàng)建時(shí)發(fā)現(xiàn)配置問題，而不是在后續(xù)出現(xiàn)。

如果不存在循環(huán)依賴關(guān)系，一個(gè) Bean 在被注入到另一個(gè) Bean 之前會(huì)被完全配置。這意味著當(dāng) A 依賴于 B 時(shí)，Spring IoC 容器會(huì)先完全配置好 B（包括實(shí)例化 Bean、設(shè)置依賴關(guān)系和調(diào)用相關(guān)的生命周期方法），再調(diào)用 A 的 Setter 方法。

依賴注入示例

下面寫下示例，快速回顧下上面的兩種注入方式，幫助大家更好理解在以 XML 作為配置元數(shù)據(jù)的情況下，使用基于構(gòu)造方法的 DI 和基于 Setter 的 DI。

基于構(gòu)造方法的 DI：

package cn.god23bin.demo.service;
import cn.god23bin.demo.repository.UserRepository;
public class UserService {
    // UserService 的依賴項(xiàng) UserRepository
	private UserRepository userRepository;
    // 使用構(gòu)造方法進(jìn)行 DI，將 UserRepository 注入到 UserService
	public UserService(UserRepository userRepository) {
    	this.userRepository = userRepository;
	}
}

<bean id="userService" class="cn.god23bin.demo.service.UserService">
   <constructor-arg ref="userRepository" />
</bean>
<bean id="userRepository" class="cn.god23bin.demo.repository.UserRepository" />

基于 Setter 的 DI：

package cn.god23bin.demo.service;
import cn.god23bin.demo.repository.UserRepository;
public class UserService {
	private UserRepository userRepository;
	public void setUserRepository(UserRepository userRepository) {
		this.userRepository = userRepository;
	}
}

<bean id="userService" class="cn.god23bin.demo.service.UserService">
   <property name="userRepository" ref="userRepository" />
</bean>
<bean id="userRepository" class="cn.god23bin.demo.repository.UserRepository" />

總結(jié)

本文開頭舉了個(gè)例子講了什么是依賴注入，實(shí)際上就是一個(gè)過程，把一個(gè) Bean 注入到另一個(gè) Bean 中的過程。

這個(gè)過程，在 Spring 中有兩種方式來實(shí)現(xiàn)，一種是基于構(gòu)造方法的 DI，另一種是基于 Setter 的DI。當(dāng)然，網(wǎng)上講到的依賴注入，還有好幾種方式，目前對(duì)于我們來說，知道這兩種就 OK。

對(duì)于這兩種 DI，我們也說了如何選擇，具體看官網(wǎng)的說法，推薦的是基于構(gòu)造方法的 DI，當(dāng)然，具體問題具體分析，有時(shí)候是需要用到基于 Setter 的 DI 的，比如解決循環(huán)依賴的時(shí)候。

接著也說了依賴的處理過程，簡單點(diǎn)就是 Spring 會(huì)先根據(jù)配置元數(shù)據(jù)去創(chuàng)建 ApplicationContext 這個(gè)作為 Spring IoC 容器，在容器創(chuàng)建時(shí)，會(huì)驗(yàn)證 Bean 是否正確配置了，默認(rèn)單例的 Bean 會(huì)先被創(chuàng)建等等等的處理。同時(shí)可能遇到循環(huán)依賴的問題，一種解決方案就是將某一個(gè) Bean 使用 Setter 的方式注入依賴項(xiàng)。

以上就是深入了解Spring中的依賴注入DI的詳細(xì)內(nèi)容，更多關(guān)于Spring依賴注入的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

最新評(píng)論