Spring IoC是如何進行依賴注入的

時間  2020-08-06
標籤 spring ioc 如何 進行 依賴 注入 欄目 Spring 简体版
原文   原文鏈接

依賴注入（DI）

DI（Dependency Injection），Spring IoC 不是一種技術，而是一種思想，經過這種思想，可以指導咱們設計出鬆耦合的程序代碼。而Spring IoC這個思想的做用體如今兩個方面，一是如何將Bean裝配到容器中去以及如何從容器中獲取Bean，二是如何解決Bean之間的依賴關係，換句話說，就是若是由IoC容器來管理依賴關係，當一個Bean須要依賴另一個Bean時，IoC容器如何實現這樣的依賴關係。html

解決Spring中Bean之間的依賴的實現方式，在Spring的概念中就被稱之爲依賴注入（Dependency Injection，DI）。廣泛認爲的Spring依賴注入的實現方式有三種：構造方法注入、setter方法注入、註解注入。但，就我而言，我認爲應該劃分爲兩種形式——基於XML注入和基於註解注入，而後再細分爲下面的形式：java

DI實現.png

基於XML的注入方式是咱們最早學習和使用的方式，也是最熟悉的方式，就簡單的作個介紹，舉個例子。spring

  • 經過構造方法注入
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注入實例。ide

<!--註冊userDao-->
<bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean>

<!--註冊userService 並注入userDao-->
<bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

最後在Spring XML配置文件中注入相應的bean實例。學習

經過構造方法的注入，必需要注入類中具備對應的構造方法，若沒有對應的構造方法，會出現報錯。測試

  • 經過setter方法注入

修改UserServiceImpl.java爲：ui

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    
    /**繼承自UserService的方法**/
}

再修改XML文件內容爲：this

<!--註冊userDao-->
<bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean>

<!--註冊userService 並注入userDao-->
<bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
</bean>

這兩種方式的區別在於，1、UserServiceImpl.java能夠不用添加構造方法，可是必須存在一個無參構造方法（如public UserServiceImpl()，示例裏面沒寫，是由於java默認會提供一個無參構造方法）以供Spring 容器註冊生成Bean（如userService）。2、XML文件中，採用構造方法注入時，須要使用<constructor-arg ></constructor-arg>這對標籤；而在setter方法注入時，使用<property ></property>標籤。設計

在XML注入過程當中，除了使用ref=""引用以外，還可使用value=""設定具體的值，其效果和使用註解@Value差很少。

基於註解的依賴注入

@Autowired
  • 源碼
@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可以標註在哪些類型上面。

  • 經過構造方法注入
@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方法注入
@Service("userService")
public class UserServiceImpl implements UserService {

    private UserDao userDao;

	@Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    /**繼承自UserService的方法**/
}
  • 經過字段注入
@Service("userService")
public class UserServiceImpl implements UserService {

	@Autowired
    private UserDao userDao;
    
    /**繼承自UserService的方法**/
}
  • 經過方法入參注入

上面三種注入方式，都是比較熟悉的就再也不多作闡述了。重點說一下參數注入，其實方法入參注入方式感受上是和構造方法、setter方法注入形式差很少，至關於將構造方法、setter方法上的註解@Autowired放到入參的位置。提及來可能有些抽象，直接看例子：

@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;
    }
}
//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);
    }
}
//簡單的配置類
//做用就是爲標有@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;
    }
}
//測試類
//注意：使用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) 中的輸出結果：

di-test1.png

public void testAutowired()測試方法中的輸出結果：

di-test2.png

注意這裏public UserServiceImpl(@Autowired UserDao userDao，@Autowired User user)的入參：

userDao是UserServiceImpl的字段，但user不是。也就是說，咱們能夠在構造方法中添加任意參數，只要是咱們須要的，不必定要求該參數是類中屬性字段。

此外還有須要注意的是，這裏所說的方法，不是任意的方法，而是構造方法或setter方法，這種public void initService(@Autowired UserDao userDao)自定義的方法是沒法完成注入的。

@Primary 和 @Qualifier

在上面的例子中，咱們注入使用到的bean，都只是容器中只有一個Bean實例的狀況。那麼當容器當中出現多個同類型的Bean時，如何處理呢？

修改配置類代碼以下：

@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;
    }
}

修改測試類：

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
    
    @Autowired
    private User user;

    @Test
    public void testAutowiredPriamry(){
        System.out.println(user);
    }
}

當不作其餘處理時，結果爲：

di-test-priority.png

由於有兩個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
@Target({ElementType.TYPE,	// 類、接口、枚舉類型
         ElementType.METHOD})// 方法
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {
}

@Primary是一個設定相同類型Bean優先級的註解，也就是說，一旦在某個類型上添加@Priamry，當注入時，沒有明確指定Bean時，就會注入被@Priamry標識的Bean。

@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。

@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可以出現的地方，與之配套使用。好比下面這樣：

@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。這個參考文檔當中有着更加詳細、豐富的介紹。

總結

總得來講，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

有收穫？但願老鐵們來個三連擊，給更多的人看到這篇文章

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程