Spring依賴注入與自動裝配

阿新 • • 發佈：2021-02-10

Spring依賴注入與自動裝配

1.Beans.xml作用

簡而言之，我們通過在beans.xml中進行配置，將各種類交給spring來管理。

2.依賴注入

這要從控制反轉說起，控制反轉是一種通過描述（XML或註解）並通過第三方去生產或獲取特定物件的方式。在Spring中實現控制反轉的是IoC容器，其實現方法是依賴注入（Dependency Injection,DI）。所謂的IoC,一句話搞定 : 物件由Spring 來建立 , 管理 , 裝配 !

常用的注入方式主要有三種：構造方法注入，setter注入（必須有set方法），基於註解的注入。其中註解最為常用。

2.1構造方法注入

先簡單瞭解一下測試專案的結構，用maven構建的，四個包：

entity：儲存實體，裡面只有一個User類 dao：
資料訪問，一個介面，兩個實現類
service：服務層，一個介面，一個實現類，實現類依賴於IUserDao
test：測試包

在spring的配置檔案中註冊UserService，將UserDaoJdbc通過constructor-arg標籤注入到UserService的某個有引數的構造方法

<!-- 註冊userService -->
< 
bean id="userService" class="com.lyu.spring.service.impl.UserService">
	<constructor-arg ref="userDaoJdbc"></constructor-arg>
</bean>
<!-- 註冊jdbc實現的dao -->
<bean id="userDaoJdbc" class="com.lyu.spring.dao.impl.UserDaoJdbc" 
></bean>

如果只有一個有引數的構造方法並且引數型別與注入的bean的型別匹配，那就會注入到該構造方法中。

public class UserService implements IUserService {

	private IUserDao userDao;
	
	public UserService(IUserDao userDao) {
		this.userDao = userDao;
	}
	
	public void loginUser() {
		userDao.loginUser();
	}

}

@Test
public void testDI() {
	ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	// 獲取bean物件
	UserService userService = ac.getBean(UserService.class, "userService");
	// 模擬使用者登入
	userService.loginUser();
}

測試列印結果：jdbc-登入成功

注：模擬使用者登入的loginUser方法其實只是列印了一條輸出語句，jdbc實現的類輸出的是：jdbc-登入成功，mybatis實現的類輸出的是：mybatis-登入成功。

問題一：如果有多個有引數的構造方法並且每個構造方法的引數列表裡面都有要注入的屬性，那userDaoJdbc會注入到哪裡呢？

public class UserService implements IUserService {

	private IUserDao userDao;
	private User user;
	
	public UserService(IUserDao userDao) {
		System.out.println("這是有一個引數的構造方法");
		this.userDao = userDao;
	}
	
	public UserService(IUserDao userDao, User user) {
		System.out.println("這是有兩個引數的構造方法");
		this.userDao = userDao;
		this.user = user;
	}
	
	public void loginUser() {
		userDao.loginUser();
	}

}

結果：會注入到只有一個引數的構造方法中，並且經過測試注入哪一個構造方法與構造方法的順序無關
在這裡插入圖片描述

問題二：如果只有一個構造方法，但是有兩個引數，一個是待注入的引數，另一個是其他型別的引數，那麼這次注入可以成功嗎？

public class UserService implements IUserService {

	private IUserDao userDao;
	private User user;
	
	public UserService(IUserDao userDao, User user) {
		this.userDao = userDao;
		this.user = user;
	}
	
	public void loginUser() {
		userDao.loginUser();
	}

}

結果：失敗了，即使在costract-arg標籤裡面通過name屬性指定要注入的引數名userDao也會失敗.
在這裡插入圖片描述
問題三：如果我們想向有多個引數的構造方法中注入值該在配置檔案中怎麼寫呢？

public class UserService implements IUserService {

	private IUserDao userDao;
	private User user;
	
	public UserService(IUserDao userDao, User user) {
		this.userDao = userDao;
		this.user = user;
	}
	
	public void loginUser() {
		userDao.loginUser();
	}

}

參考寫法：通過name屬性指定要注入的值，與構造方法引數列表引數的順序無關。

<!-- 註冊userService -->
<bean id="userService" class="com.lyu.spring.service.impl.UserService">
	<constructor-arg name="userDao" ref="userDaoJdbc"></constructor-arg>
	<constructor-arg name="user" ref="user"></constructor-arg>
</bean>

<!-- 註冊實體User類，用於測試 -->
<bean id="user" class="com.lyu.spring.entity.User"></bean>

<!-- 註冊jdbc實現的dao -->
<bean id="userDaoJdbc" class="com.lyu.spring.dao.impl.UserDaoJdbc"></bean>

問題四：如果有多個構造方法，每個構造方法只有引數的順序不同，那通過構造方法注入多個引數會注入到哪一個呢？

public class UserService implements IUserService {

	private IUserDao userDao;
	private User user;
	
	public UserService(IUserDao userDao, User user) {
		System.out.println("這是第二個構造方法");
		this.userDao = userDao;
		this.user = user;
	}
	
	public UserService(User user, IUserDao userDao) {
		System.out.println("這是第一個構造方法");
		this.userDao = userDao;
		this.user = user;
	}
	
	public void loginUser() {
		userDao.loginUser();
	}

}

結果：哪個構造方法在前就注入哪一個，這種情況下就與構造方法順序有關。
在這裡插入圖片描述

2.2setter注入（需要set方法）

配置檔案如下：

<!-- 註冊userService -->
<bean id="userService" class="com.lyu.spring.service.impl.UserService">
	<!-- 寫法一 -->
	<!-- <property name="UserDao" ref="userDaoMyBatis"></property> -->
	<!-- 寫法二 -->
	<property name="userDao" ref="userDaoMyBatis"></property>
</bean>

<!-- 註冊mybatis實現的dao -->
<bean id="userDaoMyBatis" class="com.lyu.spring.dao.impl.UserDaoMyBatis"></bean>

注：上面這兩種寫法都可以,spring會將name值的每個單詞首字母轉換成大寫，然後再在前面拼接上"set"構成一個方法名,然後去對應的類中查詢該方法,通過反射呼叫,實現注入。

切記：name屬性值與類中的成員變數名以及set方法的引數名都無關，只與對應的set方法名有關，下面的這種寫法是可以執行成功的

public class UserService implements IUserService {

	private IUserDao userDao1;
	
	public void setUserDao(IUserDao userDao1) {
		this.userDao1 = userDao1;
	}
	
	public void loginUser() {
		userDao1.loginUser();
	}

}

還有一點需要注意：如果通過set方法注入屬性，那麼spring會通過預設的空參構造方法來例項化物件，所以如果在類中寫了一個帶有引數的構造方法，一定要把空引數的構造方法寫上，否則spring沒有辦法例項化物件，導致報錯。
在這裡插入圖片描述

2.3基於註解的注入

在介紹註解注入的方式前，先簡單瞭解bean的一個屬性autowire，autowire主要有三個屬性值：constructor，byName，byType。

1.constructor：通過構造方法進行自動注入，spring會匹配與構造方法引數型別一致的bean進行注入，如果有一個多引數的構造方法，一個只有一個引數的構造方法，在容器中查詢到多個匹配多引數構造方法的bean，那麼spring會優先將bean注入到多引數的構造方法中。

2.byName：被注入bean的id名必須與set方法後半截匹配，並且id名稱的第一個單詞首字母必須小寫，這一點與手動set注入有點不同。

3.byType：查詢所有的set方法，將符合符合引數型別的bean注入。

下面進入正題：註解方式註冊bean，注入依賴

主要有四種註解可以註冊bean，每種註解可以任意使用，只是語義上有所差異：

@Component：可以用於註冊所有bean
@Repository：主要用於註冊dao層的bean
@Controller：主要用於註冊控制層的bean
@Service：主要用於註冊服務層的bean

描述依賴關係主要有兩種：

[email protected]：java的註解，預設以byName的方式去匹配與屬性名相同的bean的id，如果沒有找到就會以byType的方式查詢，如果byType查詢到多個的話，使用@Qualifier註解（spring註解）指定某個具體名稱的bean。

@Resource
@Qualifier("userDaoMyBatis")
private IUserDao userDao;

public UserService(){
	
}

[email protected]：spring註解，預設是以byType的方式去匹配型別相同的bean，如果只匹配到一個，那麼就直接注入該bean，無論要注入的 bean 的 name 是什麼；如果匹配到多個，就會呼叫 DefaultListableBeanFactory 的 determineAutowireCandidate 方法來決定具體注入哪個bean。determineAutowireCandidate 方法的內容如下：

// candidateBeans 為上一步通過型別匹配到的多個bean，該 Map 中至少有兩個元素。
protected String determineAutowireCandidate(Map<String, Object> candidateBeans, DependencyDescriptor descriptor) {
    //  requiredType 為匹配到的介面的型別
   Class<?> requiredType = descriptor.getDependencyType();
   // 1. 先找 Bean 上有@Primary 註解的，有則直接返回
   String primaryCandidate = this.determinePrimaryCandidate(candidateBeans, requiredType);
   if (primaryCandidate != null) {
       return primaryCandidate;
   } else {
       // 2.再找 Bean 上有 @Order，@PriorityOrder 註解的，有則返回
       String priorityCandidate = this.determineHighestPriorityCandidate(candidateBeans, requiredType);
       if (priorityCandidate != null) {
           return priorityCandidate;
       } else {
           Iterator var6 = candidateBeans.entrySet().iterator();

           String candidateBeanName;
           Object beanInstance;
           do {
               if (!var6.hasNext()) {
                   return null;
               }

               // 3. 再找 bean 的名稱匹配的
               Entry<String, Object> entry = (Entry)var6.next();
               candidateBeanName = (String)entry.getKey();
               beanInstance = entry.getValue();
           } while(!this.resolvableDependencies.values().contains(beanInstance) && !this.matchesBeanName(candidateBeanName, descriptor.getDependencyName()));

           return candidateBeanName;
       }
   }
}

determineAutowireCandidate 方法的邏輯是：

先找 Bean 上有@Primary 註解的，有則直接返回 bean 的 name。
再找 Bean 上有 @Order，@PriorityOrder 註解的，有則返回 bean 的 name。
最後再以名稱匹配（ByName）的方式去查詢相匹配的 bean。

可以簡單的理解為先以 ByType 的方式去匹配，如果匹配到了多個再以 ByName 的方式去匹配，找到了對應的 bean 就去注入，沒找到就丟擲異常。

還有一點要注意：如果使用了 @Qualifier 註解，那麼當自動裝配匹配到多個 bean 的時候就不會進入 determineAutowireCandidate 方法（親測），而是直接查詢與 @Qualifer 指定的 bean name 相同的 bean 去注入，找到了就直接注入，沒有找到則丟擲異常。

tips：大家如果認真思考可能會發現 ByName 的注入方式和 @Qualifier 有點類似，都是在自動裝配匹配到多個 bean 的時候，指定一個具體的 bean，那它們有什麼不同呢？

ByName 的方式需要遍歷，@Qualifier 直接一次定位。在匹配到多個 bean 的情況下，使用 @Qualifier 來指明具體裝配的 bean 效率會更高一下。

3.自動裝配

自動裝配是使用spring滿足bean依賴的一種方法
spring會在應用上下文中為某個bean尋找其依賴的bean。

Spring中bean有三種裝配機制，分別是：

在xml中顯式配置；
在java中顯式配置；
隱式的bean發現機制和自動裝配。

這裡我們主要講第三種：自動化的裝配bean。

Spring的自動裝配需要從兩個角度來實現，或者說是兩個操作：

元件掃描(component scanning)：spring會自動發現應用上下文中所建立的bean；
自動裝配(autowiring)：spring自動滿足bean之間的依賴，也就是我們說的IoC/DI；

元件掃描和自動裝配組合發揮巨大威力，使得顯示的配置降低到最少。

推薦不使用自動裝配xml配置 , 而使用註解 .

測試環境搭建

1、新建一個專案

2、新建兩個實體類，Cat Dog 都有一個叫的方法

public class Cat {
   public void shout() {
       System.out.println("miao~");
  }
}
public class Dog {
   public void shout() {
       System.out.println("wang~");
  }
}

3、新建一個使用者類 User

public class User {
   private Cat cat;
   private Dog dog;
   private String str;
}

4、編寫Spring配置檔案

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="dog" class="com.kuang.pojo.Dog"/>
   <bean id="cat" class="com.kuang.pojo.Cat"/>

   <bean id="user" class="com.kuang.pojo.User">
       <property name="cat" ref="cat"/>
       <property name="dog" ref="dog"/>
       <property name="str" value="qinjiang"/>
   </bean>
</beans>

5、測試

public class MyTest {
   @Test
   public void testMethodAutowire() {
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       User user = (User) context.getBean("user");
       user.getCat().shout();
       user.getDog().shout();
  }
}

結果正常輸出，環境OK

byName

autowire byName (按名稱自動裝配)

由於在手動配置xml過程中，常常發生字母缺漏和大小寫等錯誤，而無法對其進行檢查，使得開發效率降低。

採用自動裝配將避免這些錯誤，並且使配置簡單化。

測試：

1、修改bean配置，增加一個屬性 autowire=“byName”

<bean id="user" class="com.kuang.pojo.User" autowire="byName">
   <property name="str" value="qinjiang"/>
</bean>

2、再次測試，結果依舊成功輸出！

3、我們將 cat 的bean id修改為 catXXX

4、再次測試，執行時報空指標java.lang.NullPointerException。因為按byName規則找不對應set方法，真正的setCat就沒執行，物件就沒有初始化，所以呼叫時就會報空指標錯誤。

小結：

當一個bean節點帶有 autowire byName的屬性時。

將查詢其類中所有的set方法名，例如setCat，獲得將set去掉並且首字母小寫的字串，即cat。
去spring容器中尋找是否有此字串名稱id的物件。
如果有，就取出注入；如果沒有，就報空指標異常。

byType

autowire byType (按型別自動裝配)

使用autowire byType首先需要保證：同一型別的物件，在spring容器中唯一。如果不唯一，會報不唯一的異常。

NoUniqueBeanDefinitionException

測試：

1、將user的bean配置修改一下： autowire=“byType”

2、測試，正常輸出

3、在註冊一個cat 的bean物件！

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User" autowire="byType">
   <property name="str" value="qinjiang"/>
</bean>

4、測試，報錯：NoUniqueBeanDefinitionException

5、刪掉cat2，將cat的bean名稱改掉！測試！因為是按型別裝配，所以並不會報異常，也不影響最後的結果。甚至將id屬性去掉，也不影響結果。

這就是按照型別自動裝配！

使用註解

使用註解

jdk1.5開始支援註解，spring2.5開始全面支援註解。

準備工作：利用註解的方式注入屬性。

1、在spring配置檔案中引入context檔案頭

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2、開啟屬性註解支援！

<context:annotation-config/>

@Autowired

@Autowired是按型別自動轉配的，不支援id匹配。
需要匯入 spring-aop的包！

測試：

1、將User類中的set方法去掉，使用@Autowired註解

public class User {
   @Autowired
   private Cat cat;
   @Autowired
   private Dog dog;
   private String str;

   public Cat getCat() {
       return cat;
  }
   public Dog getDog() {
       return dog;
  }
   public String getStr() {
       return str;
  }
}

2、此時配置檔案內容

<context:annotation-config/>

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="user" class="com.kuang.pojo.User"/>

3、測試，成功輸出結果！

【小狂神科普時間】

@Autowired(required=false) 說明：false，物件可以為null；true，物件必須存物件，不能為null。

//如果允許物件為null，設定required = false,預設為true
@Autowired(required = false)
private Cat cat;

@Qualifier

@Autowired是根據型別自動裝配的，加上@Qualifier則可以根據byName的方式自動裝配
@Qualifier不能單獨使用。

測試實驗步驟：

1、配置檔案修改內容，保證型別存在物件。且名字不為類的預設名字！

<bean id="dog1" class="com.kuang.pojo.Dog"/>
<bean id="dog2" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

2、沒有加Qualifier測試，直接報錯

3、在屬性上新增Qualifier註解

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

測試，成功輸出！

@Resource

@Resource如有指定的name屬性，先按該屬性進行byName方式查詢裝配；
其次再進行預設的byName方式進行裝配；
如果以上都不成功，則按byType的方式自動裝配。
都不成功，則報異常。

實體類：

public class User {
   //如果允許物件為null，設定required = false,預設為true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

beans.xml

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User"/>

測試：結果OK

配置檔案2：beans.xml ，刪掉cat2

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>

實體類上只保留註解

@Resource
private Cat cat;
@Resource
private Dog dog;

結果：OK

結論：先進行byName查詢，失敗；再進行byType查詢，成功。

小結

@Autowired與@Resource異同：

1、@Autowired與@Resource都可以用來裝配bean。都可以寫在欄位上，或寫在setter方法上。

2、@Autowired預設按型別裝配（屬於spring規範），預設情況下必須要求依賴物件必須存在，如果要允許null 值，可以設定它的required屬性為false，如：@Autowired(required=false) ，如果我們想使用名稱裝配可以結合@Qualifier註解進行使用

3、@Resource（屬於J2EE復返），預設按照名稱進行裝配，名稱可以通過name屬性進行指定。如果沒有指定name屬性，當註解寫在欄位上時，預設取欄位名進行按照名稱查詢，如果註解寫在setter方法上預設取屬性名進行裝配。當找不到與名稱匹配的bean時才按照型別進行裝配。但是需要注意的是，如果name屬性一旦指定，就只會按照名稱進行裝配。

它們的作用相同都是用註解方式注入物件，但執行順序不同。@Autowired先byType，@Resource先byName。

問題：Spring的@Autowired加到介面上但獲取的是實現類？

原文來自https://blog.csdn.net/weixin_43575868/article/details/104535986

	/* 類 @Controller註解，會在spring容器中例項化物件 */
	@Controller
	public class UserContoller{
		@Autowired		// 先按型別找，然後按id為屬性名去找
		private UserService userService;
		//為什麼他會拿到userServiceImpl？
		// @Autowired會幫你按UserService的型別去容器中找唯一bean物件
		// 1、容器沒有該型別的物件：報錯
		// 2、容器中有該型別的唯一bean物件，就將該唯一bean物件賦值給該屬性
		///3、容器中有多個【兩個及以上】該型別的唯一bean物件，
		//     它會再根據該屬性名去容器中找，
		//     看看容器中的哪個bean物件的id值和該屬性名一致，
		//     如果有，就將容器中該物件賦值給該屬性，如果沒有報錯。
	}	
	/* 介面  */
	public interface UserService{}
	
	/* 類  @Service註解，會在spring容器中例項化物件 */
	@Service
	public class UserServiceImpl implements UserService{}
1234567891011121314151617181920

為什麼他會拿到userServiceImpl？

@Autowired先按型別找，然後再按id為屬性名去找
他會幫你按UserService的型別去容器中找唯一bean物件

容器沒有該型別的物件：報錯
容器中有該型別的唯一bean物件，就將該唯一bean物件賦值給該屬性
容器中有多個【兩個及以上】該型別的唯一bean物件，
它會再根據該屬性名去容器中找，
看看容器中的哪個bean物件的id值和該屬性名一致，
如果有，就將容器中該物件賦值給該屬性，如果沒有報錯。

然後通過多型的向上轉型就賦值成功。等價於之前手動賦值

UserService userService = new UserServiceImpl();

問題：同一介面有多個實現類，如何注入？@Resource、@Autowired、@Qualifier

原文來自https://blog.csdn.net/u010476994/article/details/80986435

先寫一個場景，舉例說明：

1、介面：IAnimal

public Interface IAnimal{

    ......

}

2、實現類：DogImpl ，實現了IAnimal介面。

@Service("dogImpl")

public class DaoImpl impliments IAnimal{

    ...

}

3、業務類：AnimalController

public class AnimalController {

    @Autowired

    private IAnimal dogImpl;

    ......

}

假如有一個“動物”的介面 IAnimal， DogImpl類實現了介面 IAnimal，且該介面只有 DogImpl這一個實現類，那麼在引用實現類的時候，我們使用的是實現類的介面（像上面程式展示的那樣）。Spring會按 byType的方式尋找介面的實現類，將其注入。

假如有另一個實現類 CatImpl 也實現了介面 IAnimal，這時候再按上面的方式去引用，在同時存在兩個實現類的情況下，會出現什麼情況呢？

答：會報錯。這是由於 @Autowired 的特性決定的： @Autowired 的注入方式是 byType 注入，當要注入的型別在容器中存在多個時，Spring是不知道要引入哪個實現類的，所以會報錯。

那麼在同一型別擁有多個實現類的時候，如何注入呢？

答：這種場景下，只能通過 byName 注入的方式。可以使用 @Resource 或 @Qualifier 註解。

@Resource 預設是按照 byName 的方式注入的，如果通過 byName 的方式匹配不到，再按 byType 的方式去匹配。所以上面的引用可以替換為：

public class AnimalController {

    @Resource(name="dogImpl")        //實現類1中 @Service註解中標定的名稱

    private IAnimal dogImpl;
    ......

}

@Qualifier 註解也是 byName的方式，但是與@Resource 有區別，@Qualifier 使用的是 ****類名****。

public class AnimalController {



    @Qualifier("DaoImpl")        //實現類1的類名。注意區分與@Resource(name="dogImpl") 的區別。

    private IAnimal dogImpl;

    ......

}

總結：

1、@Autowired 是通過 byType 的方式去注入的，使用該註解，要求介面只能有一個實現類。

2、@Resource 可以通過 byName 和 byType的方式注入，預設先按 byName的方式進行匹配，如果匹配不到，再按 byType的方式進行匹配。

3、@Qualifier 註解可以按名稱注入，但是注意是類名。

Spring依賴注入與自動裝配

Spring依賴注入與自動裝配

1.Beans.xml作用

2.依賴注入

2.1構造方法注入

2.2setter注入（需要set方法）

2.3基於註解的注入

3.自動裝配

autowire byName (按名稱自動裝配)

autowire byType (按型別自動裝配)

問題：Spring的@Autowired加到介面上但獲取的是實現類？

問題：同一介面有多個實現類，如何注入？@Resource、@Autowired、@Qualifier

Spring依賴注入與自動裝配

Spring框架(二)Spring依賴注入DI、Bean作用域、Bean的自動裝配

spring依賴注入原理與用法例項分析

iOS 依賴注入與Objection

spring依賴注入知識點分享

理解PHP 依賴注入與容器

java後端開發三年！你還不瞭解Spring 依賴注入，憑什麼給你漲薪

7.Spring中Bean的自動裝配

php設計模式-簡單依賴注入容器+自動繫結特性

spring——依賴注入的三種方式

Spring 依賴注入

Spring 依賴注入的幾種方式

Spring--->Bean的自動裝配

Spring Boot架構篇 - 自動裝配的順序性

Spring依賴注入基礎以及實現原理

Spring 依賴注入最佳實踐

Spring 依賴注入實現示例

Spring依賴注入的方式

Web API 依賴注入與擴充套件

spring依賴注入

Spring依賴注入與自動裝配

Spring依賴注入與自動裝配

1.Beans.xml作用

2.依賴注入

2.1構造方法注入

2.2setter注入（需要set方法）

2.3基於註解的注入

3.自動裝配

autowire byName (按名稱自動裝配)

autowire byType (按型別自動裝配)

問題：Spring的@Autowired加到介面上但獲取的是實現類？

問題：同一介面有多個實現類，如何注入？@Resource、@Autowired、@Qualifier

相關推薦