Spring IoC是如何進行依賴注入的
阿新 • • 發佈：2020-08-05
## 依賴注入（DI）
**DI（Dependency Injection）**，Spring IoC 不是一種技術，而是一種思想，通過這種思想，能夠指導我們設計出鬆耦合的程式程式碼。而Spring IoC這個思想的作用體現在兩個方面，一是如何將Bean裝配到容器中去以及如何從容器中獲取Bean，二是如何解決Bean之間的依賴關係，換句話說，就是如果由IoC容器來管理依賴關係，當一個Bean需要依賴另外一個Bean時，IoC容器如何實現這樣的依賴關係。
解決Spring中Bean之間的依賴的實現方式，在Spring的概念中就被稱之為**依賴注入（Dependency Injection，DI）**。普遍認為的Spring依賴注入的實現方式有三種：構造方法注入、setter方法注入、註解注入。但，就我而言，我認為應該劃分為兩種形式——基於XML注入和基於註解注入，然後再細分為下面的形式：
基於XML的注入方式是我們最先學習和使用的方式，也是最熟悉的方式，就簡單的做個介紹，舉個例子。
+ **通過構造方法注入**
```java
public class UserServiceImpl implements UserService {
private UserDao userDao;
public UserServiceImpl(UserDao userDao) {
this.userDao = userDao;
}
/**繼承自UserService的方法**/
}
```
首先定義一個服務層`UserServiceImpl`，然後在其內部增加對dao層的引用`userDao`。
接下來就是新增一個構造方法`public UserServiceImpl(UserDao userDao)`以待Spring通過這個方法為`userDao`注入例項。
```xml
```
最後在Spring XML配置檔案中注入相應的bean例項。
通過構造方法的注入，必須要注入類中具有對應的構造方法，若沒有對應的構造方法，會出現報錯。
+ **通過setter方法注入**
修改`UserServiceImpl.java`為：
```java
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
/**繼承自UserService的方法**/
}
```
再修改XML檔案內容為：
```xml
```
這兩種方式的區別在於，一、`UserServiceImpl.java`可以不用新增構造方法，但是必須存在一個無參構造方法（如`public UserServiceImpl()`，示例裡面沒寫，是因為java預設會提供一個無參構造方法）以供Spring 容器註冊生成Bean（如`userService`）。二、XML檔案中，採用構造方法注入時，需要使用``這對標籤；而在setter方法注入時，使用``標籤。
*在XML注入過程中，除了使用`ref=""`引用之外，還可以使用`value=""`設定具體的值，其效果和使用註解`@Value`差不多。*
## 基於註解的依賴注入
##### @Autowired
+ **原始碼**
```java
@Target({ElementType.CONSTRUCTOR,
ElementType.METHOD,
ElementType.PARAMETER,
ElementType.FIELD,
ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
boolean required() default true;
}
```
`@Autowired`是基於註解的依賴注入的關鍵點，它的原始碼非常簡單，只有一個引數`request()`，這個引數的作用是標識注入Bean是否一定要注入，也就是說，在Spring容器沒有找到相應Bean時，如果其值為`true`，就會報出異常；如果其值為`false`，就不會出現異常，但在使用過程中，如果容器一直不對Bean進行注入，那麼有可能出現空指標異常。
另外一點就是，原始碼當中的`@Target`所包含的引數正好就是基於註解的依賴注入的注入方式種類，`@Target`決定了`@Autowired`能夠標註在哪些型別上面。
+ **通過構造方法注入**
```java
@Service("userService")
public class UserServiceImpl implements UserService {
private UserDao userDao;
@Autowired
public UserServiceImpl(UserDao userDao) {
this.userDao = userDao;
}
/**繼承自UserService的方法**/
}
```
根據開發文件的說法，這種只有一個構造方法的情況，自Spring4.3以後，就不再需要新增` @Autowired`標註，也可以。但是，如果有多個構造方法時，是必須要對其中一個方法標註` @Autowired`,不然Spring會報出異常。
+ **通過setter方法注入**
```java
@Service("userService")
public class UserServiceImpl implements UserService {
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
/**繼承自UserService的方法**/
}
```
+ **通過欄位注入**
```java
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
/**繼承自UserService的方法**/
}
```
+ **通過方法入參注入**
上面三種注入方式，都是比較熟悉的就不再多做闡述了。重點說一下引數注入，其實方法入參注入方式感覺上是和構造方法、setter方法注入形式差不多，相當於將構造方法、setter方法上的註解`@Autowired`放到入參的位置。說起來可能有些抽象，直接看例子：
```java
@Component
public class UserDaoImpl implements UserDao {
//簡單返回一個User，模擬資料庫查詢過程
@Override
public User getUser(Long id, String name){
User user = new User();
user.setId(id);
user.setName(name);
user.setAccount("12345678911");
user.setPassword("******");
user.setOtherInfo("this is a test account");
return user;
}
}
```
```java
//UserService類
@Service("userService")
public class UserServiceImpl implements UserService {
private UserDao userDao;
public UserServiceImpl(@Autowired UserDao userDao，
@Autowired User user) {
System.out.println("UserServiceImpl: "+user);
this.userDao = userDao;
}
@Override
public User getUser(Long id, String name){
return userDao.getUser(id,name);
}
}
```
```java
//簡單的配置類
//作用就是為標有@Componet（@Service也算）註解的類 生成Bean
//同時 為@Autowired標識下的Bean（物件） 注入例項
@Configuration
@ComponentScan
public class DIConfig {
//用於Service類中入參user的注入
@Bean
public User getUser(){
User u = new User();
u.setName("user inject into service");
return u;
}
}
```
```java
//測試類
//注意：使用JUnit4測試時，如果需要使用@Autowired注入那麼必須新增
//@RunWith 標註使用Spring方式啟動（或者SpringBootRunner）
//@ContextConfiguration 掃描配置類
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
//如果不新增測試類上兩個註解，會注入失敗
@Autowired
private UserService userService;
@Test
public void testAutowired(){ System.out.println(userService.getUser(1L,"name"));
}
}
```
執行測試方法之後就得到以下結果：
`public UserServiceImpl(@Autowired UserDao userDao，@Autowired User user) `中的輸出結果：
`public void testAutowired()`測試方法中的輸出結果：
**注意這裡`public UserServiceImpl(@Autowired UserDao userDao，@Autowired User user)`的入參：**
`userDao`是`UserServiceImpl`的欄位，但`user`不是。也就是說，我們可以在構造方法中新增任意引數，只要是我們需要的，不一定要求該引數是類中屬性欄位。
此外還有需要注意的是，這裡所說的方法，不是任意的方法，而是構造方法或setter方法，這種`public void initService(@Autowired UserDao userDao)`自定義的方法是無法完成注入的。
##### @Primary 和 @Qualifier
在上面的例子中，我們注入使用到的bean，都只是容器中只有一個Bean例項的情況。那麼當容器當中出現多個同類型的`Bean`時，如何處理呢？
修改配置類程式碼如下：
```java
@Configuration
@ComponentScan
public class DIConfig {
@Bean
public User getUser(){
User u = new User();
u.setName("this is user");
return u;
}
@Bean
public User getUser2(){
User u = new User();
u.setName("this is user2");
return u;
}
}
```
修改測試類：
```java
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
@Autowired
private User user;
@Test
public void testAutowiredPriamry(){
System.out.println(user);
}
}
```
當不做其他處理時，結果為：
因為有兩個User Bean（`getUser , getUser2` ，@Bean未註明的情況下，預設方法名為Bean Name）的存在，所以Spring無法確定使用那個進行注入。
修改方式：
+ 在`@Bean`中設定name，如`@Bean(name="user")`，當名字能夠匹配上`private User user;`時，也能完成注入。
+ 將`private User user`改寫成`getUser`或`getUser2`任意一個，也能完成注入。道理和上面一樣，Spring首先會按照type進行匹配，如果無法匹配，再按照名字匹配，都匹配不上時，自然丟擲異常。
除此之外呢，Spring為我們提供了兩個註解來消除依賴注入時的歧義問題。
+ `@Primary`
```java
@Target({ElementType.TYPE, // 類、介面、列舉型別
ElementType.METHOD})// 方法
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {
}
```
`@Primary`是一個設定相同型別Bean優先順序的註解，也就是說，一旦在某個型別上新增`@Priamry`，當注入時，沒有明確指定Bean時，就會注入被`@Priamry`標識的Bean。
```java
@Configuration
@ComponentScan
public class DIConfig {
@Primary
@Bean
public User getUser(){
User u = new User();
u.setName("this is user");
return u;
}
@Bean
public User getUser2(){
User u = new User();
u.setName("this is user2");
return u;
}
}
```
比如上面這樣，在`getUser()`上新增相應註解，測試方法也能正常執行。
但是這種方法的問題就在於`@Priamry`可以用在很多類上，如果同一型別有多個Bean被標註了`@Primary`，那麼`@Priamry`就失去了應有的效果。
+ `@Qualifier`
因此，Spring又提供了`@Qualifier`這個註解，直接標註在`@Autowired`注入的Bean上，為其明確指定注入某個Bean。
```java
@Target({ElementType.FIELD,
ElementType.METHOD,
ElementType.PARAMETER,
ElementType.TYPE,
ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {
String value() default "";
}
```
`@Qualifier`可以出現任何`@Autowired`能夠出現的地方，與之配套使用。比如下面這樣：
```java
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
//直接指定使用getUser2進行注入
@Autowired
@Qualifier("getUser2")
private User user;
@Test
public void testAutowiredPriamry(){
System.out.println(user);
}
}
```
這兩種註解都可以消除歧義，推薦使用**`@Bean(name="xxx")和@Qualifier(value="xxx")`**組合使用的方式`。但是如果開發環境中沒有歧義的存在，自然也就不需要使用這些了。
當然，上面只是對於`@Autowired`一些常用介紹，如果想要了解更多，可以檢視[Annotation-based Container Configuration](https://docs.spring.io/spring/docs/5.3.0-SNAPSHOT/spring-framework-reference/core.html#beans-annotation-config)。這個參考文件當中有著更加詳細、豐富的介紹。
## 總結
總得來說，Spring是如何實現IoC的呢？首先，Spring提供了一個獲取和管理Bean的IoC容器。然後，再提供了一套依賴注入的機制去幫助IoC容器更好地管理各個Bean之間的依賴關係，從而更好地實現IoC的思想。一個Bean不可能完全脫離其他Bean的依賴關係而獨立存在，當一個Bean需要其他Bean的引入才能初始化時，就需要依賴注入這個機制。
舉例來說，假如存在一個A類想要去呼叫B介面的方法或者說需要B介面的一個例項。
傳統的程式流程是，使用一個C類實現B介面，然後A類建立一個C類的例項，從而呼叫其方法。
在Spring的依賴注入過程中就變成了，A類只需要在自己的內部新增一個注入介面（廣義上的介面，不是`interface`這個介面），這個介面可以是構造方法，也可以是setter方法或者說其他形式；同時新增一個對B介面的引用（`private B b;`）。
當真正需要生成A類的例項時，Spring IoC容器根據A類提供的介面，為其注入相應的Bean，而這個Bean可以是C類（`class C implements B`{}），也可以D類（`class D implements B`{}）等等；具體是誰，根據Bean的裝配策略和IoC容器中的Bean來確定，不再由開發人員管理。
---
公眾號：良許Linux
### 有收穫？希望老鐵們來個三連擊，給更多的人看到這
### 有收穫？希望老鐵們來個三連擊，給更多的人看到這