當(dāng)前位置：首頁 > 前端技术 > javascript >内容正文

javascript

Spring_day02

發(fā)布時間：2024/3/24 javascript 42 豆豆

生活随笔收集整理的這篇文章主要介紹了 Spring_day02 小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

Spring_day02

今日目標(biāo)

掌握IOC/DI配置管理第三方bean
掌握IOC/DI的注解開發(fā)
掌握IOC/DI注解管理第三方bean
完成Spring與Mybatis及Junit的整合開發(fā)

1，IOC/DI配置管理第三方bean

前面所講的知識點都是基于我們自己寫的類，現(xiàn)在如果有需求讓我們?nèi)ス芾淼谌絡(luò)ar包中的類，該如何管理?

1.1 案例:數(shù)據(jù)源對象管理

在這一節(jié)中，我們將通過一個案例來學(xué)習(xí)下對于第三方bean該如何進行配置管理。

以后我們會用到很多第三方的bean,本次案例將使用咱們前面提到過的數(shù)據(jù)源Druid(德魯伊)和C3P0來配置學(xué)習(xí)下。

1.1.1 環(huán)境準(zhǔn)備

學(xué)習(xí)之前，先來準(zhǔn)備下案例環(huán)境:

創(chuàng)建一個Maven項目

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-vX9S67tq-1652259021461)(assets/1629860338328.png)]
pom.xml添加依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency> </dependencies>
resources下添加spring的配置文件applicationContext.xml
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"></beans>
編寫一個運行類App
public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");} }

1.1.2 思路分析

在上述環(huán)境下，我們來對數(shù)據(jù)源進行配置管理，先來分析下思路:

需求:使用Spring的IOC容器來管理Druid連接池對象

1.使用第三方的技術(shù)，需要在pom.xml添加依賴

2.在配置文件中將【第三方的類】制作成一個bean，讓IOC容器進行管理

3.數(shù)據(jù)庫連接需要基礎(chǔ)的四要素驅(qū)動、連接、用戶名和密碼，【如何注入】到對應(yīng)的bean中

4.從IOC容器中獲取對應(yīng)的bean對象，將其打印到控制臺查看結(jié)果

思考:

第三方的類指的是什么?
如何注入數(shù)據(jù)庫連接四要素?

1.1.3 實現(xiàn)Druid管理

帶著這兩個問題，把下面的案例實現(xiàn)下:

步驟1:導(dǎo)入druid的依賴

pom.xml中添加依賴

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.16</version> </dependency>

步驟2:配置第三方bean

在applicationContext.xml配置文件中添加DruidDataSource的配置

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/spring_db"/><property name="username" value="root"/><property name="password" value="root"/></bean> </beans>

說明:

driverClassName:數(shù)據(jù)庫驅(qū)動
url:數(shù)據(jù)庫連接地址
username:數(shù)據(jù)庫連接用戶名
password:數(shù)據(jù)庫連接密碼
數(shù)據(jù)庫連接的四要素要和自己使用的數(shù)據(jù)庫信息一致。

步驟3:從IOC容器中獲取對應(yīng)的bean對象

public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = (DataSource) ctx.getBean("dataSource");System.out.println(dataSource);} }

步驟4:運行程序

打印如下結(jié)果: 說明第三方bean對象已經(jīng)被spring的IOC容器進行管理

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-e9iEXfIH-1652259021462)(assets/1629887733081.png)]

做完案例后，我們可以將剛才思考的兩個問題答案說下:

第三方的類指的是什么?
DruidDataSource
如何注入數(shù)據(jù)庫連接四要素?
setter注入

1.1.4 實現(xiàn)C3P0管理

完成了DruidDataSource的管理，接下來我們再來加深下練習(xí)，這次我們來管理C3P0數(shù)據(jù)源，具體的實現(xiàn)步驟是什么呢?

需求:使用Spring的IOC容器來管理C3P0連接池對象

實現(xiàn)方案和上面基本一致，重點要關(guān)注管理的是哪個bean對象`?

步驟1:導(dǎo)入C3P0的依賴

pom.xml中添加依賴

對于新的技術(shù)，不知道具體的坐標(biāo)該如何查找?

直接百度搜索
從mvn的倉庫https://mvnrepository.com/中進行搜索

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-LvNhwrba-1652259021463)(assets/1629888540286.png)]

步驟2:配置第三方bean

在applicationContext.xml配置文件中添加配置

注意:

ComboPooledDataSource的屬性是通過setter方式進行注入
想注入屬性就需要在ComboPooledDataSource類或其上層類中有提供屬性對應(yīng)的setter方法
C3P0的四個屬性和Druid的四個屬性是不一樣的

步驟3:運行程序

程序會報錯，錯誤如下

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-5L2PlWDO-1652259021463)(assets/1629889170229.png)]

報的錯為ClassNotFoundException,翻譯出來是類沒有發(fā)現(xiàn)的異常，具體的類為com.mysql.jdbc.Driver。錯誤的原因是缺少mysql的驅(qū)動包。

分析出錯誤的原因，具體的解決方案就比較簡單，只需要在pom.xml把驅(qū)動包引入即可。

<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version> </dependency>

添加完mysql的驅(qū)動包以后，再次運行App,就可以打印出結(jié)果:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-yG7H7rRT-1652259021463)(assets/1629903845404.png)]

注意：

數(shù)據(jù)連接池在配置屬性的時候，除了可以注入數(shù)據(jù)庫連接四要素外還可以配置很多其他的屬性，具體都有哪些屬性用到的時候再去查，一般配置基礎(chǔ)的四個，其他都有自己的默認值
Druid和C3P0在沒有導(dǎo)入mysql驅(qū)動包的前提下，一個沒報錯一個報錯，說明Druid在初始化的時候沒有去加載驅(qū)動，而C3P0剛好相反
Druid程序運行雖然沒有報錯，但是當(dāng)調(diào)用DruidDataSource的getConnection()方法獲取連接的時候，也會報找不到驅(qū)動類的錯誤

1.2 加載properties文件

上節(jié)中我們已經(jīng)完成兩個數(shù)據(jù)源druid和C3P0的配置，但是其中包含了一些問題，我們來分析下:

這兩個數(shù)據(jù)源中都使用到了一些固定的常量如數(shù)據(jù)庫連接四要素，把這些值寫在Spring的配置文件中不利于后期維護
需要將這些值提取到一個外部的properties配置文件中
Spring框架如何從配置文件中讀取屬性值來配置就是接下來要解決的問題。

問題提出來后，具體該如何實現(xiàn)?

1.2.1 第三方bean屬性優(yōu)化

1.2.1.1 實現(xiàn)思路

需求:將數(shù)據(jù)庫連接四要素提取到properties配置文件，spring來加載配置信息并使用這些信息來完成屬性注入。

1.在resources下創(chuàng)建一個jdbc.properties(文件的名稱可以任意)

2.將數(shù)據(jù)庫連接四要素配置到配置文件中

3.在Spring的配置文件中加載properties文件

4.使用加載到的值實現(xiàn)屬性注入

其中第3，4步驟是需要大家重點關(guān)注，具體是如何實現(xiàn)。

1.2.1.2 實現(xiàn)步驟

步驟1:準(zhǔn)備properties配置文件

resources下創(chuàng)建一個jdbc.properties文件,并添加對應(yīng)的屬性鍵值對

jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db jdbc.username=root jdbc.password=root

步驟2:開啟context命名空間

在applicationContext.xml中開context命名空間

步驟3:加載properties配置文件

在配置文件中使用context命名空間下的標(biāo)簽來加載properties配置文件

<context:property-placeholder location="jdbc.properties"/>

步驟4:完成屬性注入

使用${key}來讀取properties配置文件中的內(nèi)容并完成屬性注入

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><context:property-placeholder location="jdbc.properties"/><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean> </beans>

至此，讀取外部properties配置文件中的內(nèi)容就已經(jīng)完成。

1.2.2 讀取單個屬性

1.2.2.1 實現(xiàn)思路

對于上面的案例，效果不是很明顯，我們可以換個案例來演示下:

需求:從properties配置文件中讀取key為name的值，并將其注入到BookDao中并在save方法中進行打印。

1.在項目中添加BookDao和BookDaoImpl類

2.為BookDaoImpl添加一個name屬性并提供setter方法

3.在jdbc.properties中添加數(shù)據(jù)注入到bookDao中打印方便查詢結(jié)果

4.在applicationContext.xml添加配置完成配置文件加載、屬性注入(${key})

1.2.2.2 實現(xiàn)步驟

步驟1:在項目中添對應(yīng)的類

BookDao和BookDaoImpl類，并在BookDaoImpl類中添加name屬性與setter方法

public interface BookDao {public void save(); }public class BookDaoImpl implements BookDao {private String name;public void setName(String name) {this.name = name;}public void save() {System.out.println("book dao save ..." + name);} }

步驟2:完成配置文件的讀取與注入

在applicationContext.xml添加配置，bean的配置管理、讀取外部properties、依賴注入:

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><context:property-placeholder location="jdbc.properties"/><bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"><property name="name" value="${jdbc.driver}"/></bean> </beans>

步驟3:運行程序

在App類中，從IOC容器中獲取bookDao對象，調(diào)用方法，查看值是否已經(jīng)被獲取到并打印控制臺

public class App {public static void main(String[] args) throws Exception{ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();} }

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-1ybXvW2N-1652259021464)(assets/1629975492444.png)]

1.2.2.3 注意事項

至此，讀取properties配置文件中的內(nèi)容就已經(jīng)完成，但是在使用的時候，有些注意事項:

問題一:鍵值對的key為username引發(fā)的問題

1.在properties中配置鍵值對的時候，如果key設(shè)置為username
username=root666
2.在applicationContext.xml注入該屬性
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><context:property-placeholder location="jdbc.properties"/><bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"><property name="name" value="${username}"/></bean> </beans>
3.運行后，在控制臺打印的卻不是root666，而是自己電腦的用戶名

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-bAVfFltx-1652259021464)(assets/1629975934694.png)]

4.出現(xiàn)問題的原因是<context:property-placeholder/>標(biāo)簽會加載系統(tǒng)的環(huán)境變量，而且環(huán)境變量的值會被優(yōu)先加載，如何查看系統(tǒng)的環(huán)境變量?
public static void main(String[] args) throws Exception{Map<String, String> env = System.getenv();System.out.println(env); }
大家可以自行運行，在打印出來的結(jié)果中會有一個USERNAME=XXX[自己電腦的用戶名稱]

5.解決方案
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/> </beans>
system-properties-mode:設(shè)置為NEVER,表示不加載系統(tǒng)屬性，就可以解決上述問題。

當(dāng)然還有一個解決方案就是避免使用username作為屬性的key。
問題二:當(dāng)有多個properties配置文件需要被加載，該如何配置?

1.調(diào)整下配置文件的內(nèi)容，在resources下添加jdbc.properties,jdbc2.properties,內(nèi)容如下:

jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db jdbc.username=root jdbc.password=root
jdbc2.properties
username=root666
2.修改applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><context:property-placeholder location="jdbc.properties,jdbc2.properties" system-properties-mode="NEVER"/><context:property-placeholder location="*.properties" system-properties-mode="NEVER"/><context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/><context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/> </beans>
說明:
- 方式一:可以實現(xiàn)，如果配置文件多的話，每個都需要配置
- 方式二:*.properties代表所有以properties結(jié)尾的文件都會被加載，可以解決方式一的問題，但是不標(biāo)準(zhǔn)
- 方式三:標(biāo)準(zhǔn)的寫法，classpath:代表的是從根路徑下開始查找，但是只能查詢當(dāng)前項目的根路徑
- 方式四:不僅可以加載當(dāng)前項目還可以加載當(dāng)前項目所依賴的所有項目的根路徑下的properties配置文件

1.2.3 加載properties文件小結(jié)

本節(jié)主要講解的是properties配置文件的加載，需要掌握的內(nèi)容有:

如何開啟context命名空間

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-NvMAG5ko-1652259021465)(assets/1629980280952.png)]
如何加載properties配置文件
<context:property-placeholder location="" system-properties-mode="NEVER"/>
如何在applicationContext.xml引入properties配置文件中的值
${key}

2，核心容器

前面已經(jīng)完成bean與依賴注入的相關(guān)知識學(xué)習(xí)，接下來我們主要學(xué)習(xí)的是IOC容器中的核心容器。

這里所說的核心容器，大家可以把它簡單的理解為ApplicationContext，前面雖然已經(jīng)用到過，但是并沒有系統(tǒng)的學(xué)習(xí)，接下來咱們從以下幾個問題入手來學(xué)習(xí)下容器的相關(guān)知識:

如何創(chuàng)建容器?
創(chuàng)建好容器后，如何從容器中獲取bean對象?
容器類的層次結(jié)構(gòu)是什么?
BeanFactory是什么?

2.1 環(huán)境準(zhǔn)備

在學(xué)習(xí)和解決上述問題之前，先來準(zhǔn)備下案例環(huán)境:

創(chuàng)建一個Maven項目
pom.xml添加Spring的依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency> </dependencies>
resources下添加applicationContext.xml
<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/> </beans>
添加BookDao和BookDaoImpl類
public interface BookDao {public void save(); } public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ..." );} }
創(chuàng)建運行類App
public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();} }

最終創(chuàng)建好的項目結(jié)構(gòu)如下:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-yyYdlY5c-1652259021465)(assets/1629982672522.png)]

2.2 容器

2.2.1 容器的創(chuàng)建方式

案例中創(chuàng)建ApplicationContext的方式為:

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

這種方式翻譯為:類路徑下的XML配置文件

除了上面這種方式，Spring還提供了另外一種創(chuàng)建方式為:

ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");

這種方式翻譯為:文件系統(tǒng)下的XML配置文件

使用這種方式，運行，會出現(xiàn)如下錯誤:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-8Nsg8NNa-1652259021465)(assets/1629983245121.png)]

從錯誤信息中能發(fā)現(xiàn)，這種方式是從項目路徑下開始查找applicationContext.xml配置文件的，所以需要將其修改為:

ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\workspace\\spring\\spring_10_container\\src\\main\\resources\\applicationContext.xml");

**說明:**大家練習(xí)的時候，寫自己的具體路徑。

這種方式雖能實現(xiàn)，但是當(dāng)項目的位置發(fā)生變化后,代碼也需要跟著改,耦合度較高,不推薦使用。

2.2.2 Bean的三種獲取方式

方式一，就是目前案例中獲取的方式:

BookDao bookDao = (BookDao) ctx.getBean("bookDao");

這種方式存在的問題是每次獲取的時候都需要進行類型轉(zhuǎn)換，有沒有更簡單的方式呢?

方式二：

BookDao bookDao = ctx.getBean("bookDao"，BookDao.class);

這種方式可以解決類型強轉(zhuǎn)問題，但是參數(shù)又多加了一個，相對來說沒有簡化多少。

方式三:

BookDao bookDao = ctx.getBean(BookDao.class);

這種方式就類似我們之前所學(xué)習(xí)依賴注入中的按類型注入。必須要確保IOC容器中該類型對應(yīng)的bean對象只能有一個。

2.2.3 容器類層次結(jié)構(gòu)

(1)在IDEA中雙擊shift,輸入BeanFactory

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-uG9Cl5SV-1652259021466)(assets/1629985148294.png)]

(2)點擊進入BeanFactory類，ctrl+h,就能查看到如下結(jié)構(gòu)的層次關(guān)系

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-NSHDSVIu-1652259021467)(assets/1629984980781.png)]

從圖中可以看出，容器類也是從無到有根據(jù)需要一層層疊加上來的，大家重點理解下這種設(shè)計思想。

2.2.4 BeanFactory的使用

使用BeanFactory來創(chuàng)建IOC容器的具體實現(xiàn)方式為:

public class AppForBeanFactory {public static void main(String[] args) {Resource resources = new ClassPathResource("applicationContext.xml");BeanFactory bf = new XmlBeanFactory(resources);BookDao bookDao = bf.getBean(BookDao.class);bookDao.save();} }

為了更好的看出BeanFactory和ApplicationContext之間的區(qū)別，在BookDaoImpl添加如下構(gòu)造函數(shù):

public class BookDaoImpl implements BookDao {public BookDaoImpl() {System.out.println("constructor");}public void save() {System.out.println("book dao save ..." );} }

如果不去獲取bean對象，打印會發(fā)現(xiàn)：

BeanFactory是延遲加載，只有在獲取bean對象的時候才會去創(chuàng)建
ApplicationContext是立即加載，容器加載的時候就會創(chuàng)建bean對象
ApplicationContext要想成為延遲加載，只需要按照如下方式進行配置
<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl" lazy-init="true"/> </beans>

小結(jié)

這一節(jié)中所講的知識點包括:

容器創(chuàng)建的兩種方式
- ClassPathXmlApplicationContext[掌握]
- FileSystemXmlApplicationContext[知道即可]
獲取Bean的三種方式
- getBean(“名稱”):需要類型轉(zhuǎn)換
- getBean(“名稱”,類型.class):多了一個參數(shù)
- getBean(類型.class):容器中不能有多個該類的bean對象
上述三種方式，各有各的優(yōu)缺點，用哪個都可以。
容器類層次結(jié)構(gòu)
- 只需要知曉容器的最上級的父接口為 BeanFactory即可
BeanFactory
- 使用BeanFactory創(chuàng)建的容器是延遲加載
- 使用ApplicationContext創(chuàng)建的容器是立即加載
- 具體BeanFactory如何創(chuàng)建只需要了解即可。

2.2 核心容器總結(jié)

這節(jié)中沒有新的知識點，只是對前面知識的一個大總結(jié)，共包含如下內(nèi)容:

2.2.1 容器相關(guān)

BeanFactory是IoC容器的頂層接口，初始化BeanFactory對象時，加載的bean延遲加載
ApplicationContext接口是Spring容器的核心接口，初始化時bean立即加載
ApplicationContext接口提供基礎(chǔ)的bean操作相關(guān)方法，通過其他接口擴展其功能
ApplicationContext接口常用初始化類
- ClassPathXmlApplicationContext(常用)
- FileSystemXmlApplicationContext

2.2.2 bean相關(guān)

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-p1eFytVP-1652259021467)(assets/1629986510487.png)]

其實整個配置中最常用的就兩個屬性id和class。

把scope、init-method、destroy-method框起來的原因是，后面注解在講解的時候還會用到，所以大家對這三個屬性關(guān)注下。

2.2.3 依賴注入相關(guān)

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-EL7SXh4U-1652259021467)(assets/1629986848563.png)]

3，IOC/DI注解開發(fā)

Spring的IOC/DI對應(yīng)的配置開發(fā)就已經(jīng)講解完成，但是使用起來相對來說還是比較復(fù)雜的，復(fù)雜的地方在配置文件。

前面咱們聊Spring的時候說過，Spring可以簡化代碼的開發(fā)，到現(xiàn)在并沒有體會到。

所以Spring到底是如何簡化代碼開發(fā)的呢?

要想真正簡化開發(fā)，就需要用到Spring的注解開發(fā)，Spring對注解支持的版本歷程:

2.0版開始支持注解
2.5版注解功能趨于完善
3.0版支持純注解開發(fā)

關(guān)于注解開發(fā)，我們會講解兩塊內(nèi)容注解開發(fā)定義bean和純注解開發(fā)。

注解開發(fā)定義bean用的是2.5版提供的注解，純注解開發(fā)用的是3.0版提供的注解。

3.1 環(huán)境準(zhǔn)備

在學(xué)習(xí)注解開發(fā)之前，先來準(zhǔn)備下案例環(huán)境:

創(chuàng)建一個Maven項目
pom.xml添加Spring的依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency> </dependencies>
resources下添加applicationContext.xml
<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/> </beans>
添加BookDao、BookDaoImpl、BookService、BookServiceImpl類
public interface BookDao {public void save(); } public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ..." );} } public interface BookService {public void save(); }public class BookServiceImpl implements BookService {public void save() {System.out.println("book service save ...");} }
創(chuàng)建運行類App
public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();} }

最終創(chuàng)建好的項目結(jié)構(gòu)如下:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-8D5qBkIa-1652259021467)(assets/1629989221808.png)]

3.2 注解開發(fā)定義bean

在上述環(huán)境的基礎(chǔ)上，我們來學(xué)一學(xué)Spring是如何通過注解實現(xiàn)bean的定義開發(fā)?

步驟1:刪除原XML配置

將配置文件中的<bean>標(biāo)簽刪除掉

步驟2:Dao上添加注解

在BookDaoImpl類上添加@Component注解

@Component("bookDao") public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ..." );} }

注意:@Component注解不可以添加在接口上，因為接口是無法創(chuàng)建對象的。

XML與注解配置的對應(yīng)關(guān)系:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-bNJkJdh7-1652259021468)(assets/1629990315619.png)]

步驟3:配置Spring的注解包掃描

為了讓Spring框架能夠掃描到寫在類上的注解，需要在配置文件上進行包掃描

說明:

component-scan

component:組件,Spring將管理的bean視作自己的一個組件
scan:掃描

base-package指定Spring框架掃描的包路徑，它會掃描指定包及其子包中的所有類上的注解。

包路徑越多[如:com.itheima.dao.impl]，掃描的范圍越小速度越快
包路徑越少[如:com.itheima],掃描的范圍越大速度越慢
一般掃描到項目的組織名稱即Maven的groupId下[如:com.itheima]即可。

步驟4：運行程序

運行App類查看打印結(jié)果

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-PUxXC0WI-1652259021468)(assets/1630027590558.png)]

步驟5:Service上添加注解

在BookServiceImpl類上也添加@Component交給Spring框架管理

@Component public class BookServiceImpl implements BookService {private BookDao bookDao;public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}public void save() {System.out.println("book service save ...");bookDao.save();} }

步驟6:運行程序

在App類中，從IOC容器中獲取BookServiceImpl對應(yīng)的bean對象，打印

public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");System.out.println(bookDao);//按類型獲取beanBookService bookService = ctx.getBean(BookService.class);System.out.println(bookService);} }

打印觀察結(jié)果，兩個bean對象都已經(jīng)打印到控制臺

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-jTGAZuYb-1652259021469)(assets/1630027743910.png)]

說明:

BookServiceImpl類沒有起名稱，所以在App中是按照類型來獲取bean對象
@Component注解如果不起名稱，會有一個默認值就是當(dāng)前類名首字母小寫，所以也可以按照名稱獲取，如
BookService bookService = (BookService)ctx.getBean("bookServiceImpl"); System.out.println(bookService);

對于@Component注解，還衍生出了其他三個注解@Controller、@Service、@Repository

通過查看源碼會發(fā)現(xiàn):

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-cVlcqu3F-1652259021469)(assets/1630028345074.png)]

這三個注解和@Component注解的作用是一樣的，為什么要衍生出這三個呢?

方便我們后期在編寫類的時候能很好的區(qū)分出這個類是屬于表現(xiàn)層、業(yè)務(wù)層還是數(shù)據(jù)層的類。

知識點1:@Component等

名稱@Component/@Controller/@Service/@Repository

類型	類注解
位置	類定義上方
作用	設(shè)置該類為spring管理的bean
屬性	value（默認）：定義bean的id

3.2 純注解開發(fā)模式

上面已經(jīng)可以使用注解來配置bean,但是依然有用到配置文件，在配置文件中對包進行了掃描，Spring在3.0版已經(jīng)支持純注解開發(fā)

Spring3.0開啟了純注解開發(fā)模式，使用Java類替代配置文件，開啟了Spring快速開發(fā)賽道

具體如何實現(xiàn)?

3.2.1 思路分析

實現(xiàn)思路為:

將配置文件applicationContext.xml刪除掉，使用類來替換。

3.2.2 實現(xiàn)步驟

步驟1:創(chuàng)建配置類

創(chuàng)建一個配置類SpringConfig

public class SpringConfig { }

步驟2:標(biāo)識該類為配置類

在配置類上添加@Configuration注解，將其標(biāo)識為一個配置類,替換applicationContext.xml

@Configuration public class SpringConfig { }

步驟3:用注解替換包掃描配置

在配置類上添加包掃描注解@ComponentScan替換<context:component-scan base-package=""/>

@Configuration @ComponentScan("com.itheima") public class SpringConfig { }

步驟4:創(chuàng)建運行類并執(zhí)行

創(chuàng)建一個新的運行類AppForAnnotation

public class AppForAnnotation {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = (BookDao) ctx.getBean("bookDao");System.out.println(bookDao);BookService bookService = ctx.getBean(BookService.class);System.out.println(bookService);} }

運行AppForAnnotation,可以看到兩個對象依然被獲取成功

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-DSrpGn6R-1652259021469)(assets/1630029110506.png)]

至此，純注解開發(fā)的方式就已經(jīng)完成了，主要內(nèi)容包括:

Java類替換Spring核心配置文件

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-hXPJ1OII-1652259021470)(assets/1630029254372.png)]
@Configuration注解用于設(shè)定當(dāng)前類為配置類
@ComponentScan注解用于設(shè)定掃描路徑，此注解只能添加一次，多個數(shù)據(jù)請用數(shù)組格式
@ComponentScan({com.itheima.service","com.itheima.dao"})
讀取Spring核心配置文件初始化容器對象切換為讀取Java配置類初始化容器對象
//加載配置文件初始化容器 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); //加載配置類初始化容器 ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

知識點1：@Configuration

名稱@Configuration

類型	類注解
位置	類定義上方
作用	設(shè)置該類為spring配置類
屬性	value（默認）：定義bean的id

知識點2：@ComponentScan

名稱@ComponentScan

類型	類注解
位置	類定義上方
作用	設(shè)置spring配置類掃描路徑，用于加載使用注解格式定義的bean
屬性	value（默認）：掃描路徑，此路徑可以逐層向下掃描

小結(jié):

這一節(jié)重點掌握的是使用注解完成Spring的bean管理，需要掌握的內(nèi)容為:

記住@Component、@Controller、@Service、@Repository這四個注解
applicationContext.xml中<context:component-san/>的作用是指定掃描包路徑，注解為@ComponentScan
@Configuration標(biāo)識該類為配置類，使用類替換applicationContext.xml文件
ClassPathXmlApplicationContext是加載XML配置文件
AnnotationConfigApplicationContext是加載配置類

3.3 注解開發(fā)bean作用范圍與生命周期管理

使用注解已經(jīng)完成了bean的管理，接下來按照前面所學(xué)習(xí)的內(nèi)容，將通過配置實現(xiàn)的內(nèi)容都換成對應(yīng)的注解實現(xiàn)，包含兩部分內(nèi)容:bean作用范圍和bean生命周期。

3.3.1 環(huán)境準(zhǔn)備

老規(guī)矩，學(xué)習(xí)之前先來準(zhǔn)備環(huán)境:

創(chuàng)建一個Maven項目
pom.xml添加Spring的依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency> </dependencies>
添加一個配置類SpringConfig
@Configuration @ComponentScan("com.itheima") public class SpringConfig { }
添加BookDao、BookDaoImpl類
public interface BookDao {public void save(); } @Repository public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ..." );} }
創(chuàng)建運行類App
public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao1 = ctx.getBean(BookDao.class);BookDao bookDao2 = ctx.getBean(BookDao.class);System.out.println(bookDao1);System.out.println(bookDao2);} }

最終創(chuàng)建好的項目結(jié)構(gòu)如下:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-piBxrXqS-1652259021470)(assets/1630031112993.png)]

3.3.2 Bean的作用范圍

(1)先運行App類,在控制臺打印兩個一摸一樣的地址，說明默認情況下bean是單例

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-MKbbFNgX-1652259021471)(assets/1630031192753.png)]

(2)要想將BookDaoImpl變成非單例，只需要在其類上添加@scope注解

@Repository //@Scope設(shè)置bean的作用范圍 @Scope("prototype") public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");} }

再次執(zhí)行App類，打印結(jié)果:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-5qesqFyU-1652259021471)(assets/1630031808947.png)]

知識點1：@Scope

名稱@Scope

類型	類注解
位置	類定義上方
作用	設(shè)置該類創(chuàng)建對象的作用范圍可用于設(shè)置創(chuàng)建出的bean是否為單例對象
屬性	value（默認）：定義bean作用范圍，默認值singleton（單例），可選值prototype（非單例）

3.3.3 Bean的生命周期

(1)在BookDaoImpl中添加兩個方法，init和destroy,方法名可以任意

@Repository public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");}public void init() {System.out.println("init ...");}public void destroy() {System.out.println("destroy ...");} }

(2)如何對方法進行標(biāo)識，哪個是初始化方法，哪個是銷毀方法?

只需要在對應(yīng)的方法上添加@PostConstruct和@PreDestroy注解即可。

@Repository public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");}@PostConstruct //在構(gòu)造方法之后執(zhí)行，替換 init-methodpublic void init() {System.out.println("init ...");}@PreDestroy //在銷毀方法之前執(zhí)行,替換 destroy-methodpublic void destroy() {System.out.println("destroy ...");} }

(3)要想看到兩個方法執(zhí)行，需要注意的是destroy只有在容器關(guān)閉的時候，才會執(zhí)行，所以需要修改App的類

public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao1 = ctx.getBean(BookDao.class);BookDao bookDao2 = ctx.getBean(BookDao.class);System.out.println(bookDao1);System.out.println(bookDao2);ctx.close(); //關(guān)閉容器} }

(4)運行App,類查看打印結(jié)果，證明init和destroy方法都被執(zhí)行了。

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-EERlgPVX-1652259021471)(assets/1630032385498.png)]

注意:@PostConstruct和@PreDestroy注解如果找不到，需要導(dǎo)入下面的jar包

<dependency><groupId>javax.annotation</groupId><artifactId>javax.annotation-api</artifactId><version>1.3.2</version> </dependency>

找不到的原因是，從JDK9以后jdk中的javax.annotation包被移除了，這兩個注解剛好就在這個包中。

知識點1：@PostConstruct

名稱@PostConstruct

類型	方法注解
位置	方法上
作用	設(shè)置該方法為初始化方法
屬性	無

知識點2：@PreDestroy

名稱@PreDestroy

類型	方法注解
位置	方法上
作用	設(shè)置該方法為銷毀方法
屬性	無

小結(jié)

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-CjOrSf4t-1652259021472)(assets/1630033039358.png)]

3.4 注解開發(fā)依賴注入

Spring為了使用注解簡化開發(fā)，并沒有提供構(gòu)造函數(shù)注入、setter注入對應(yīng)的注解，只提供了自動裝配的注解實現(xiàn)。

3.4.1 環(huán)境準(zhǔn)備

在學(xué)習(xí)之前，把案例環(huán)境介紹下:

創(chuàng)建一個Maven項目
pom.xml添加Spring的依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency> </dependencies>
添加一個配置類SpringConfig
@Configuration @ComponentScan("com.itheima") public class SpringConfig { }
添加BookDao、BookDaoImpl、BookService、BookServiceImpl類
public interface BookDao {public void save(); } @Repository public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ..." );} } public interface BookService {public void save(); } @Service public class BookServiceImpl implements BookService {private BookDao bookDao;public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}public void save() {System.out.println("book service save ...");bookDao.save();} }
創(chuàng)建運行類App
public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookService bookService = ctx.getBean(BookService.class);bookService.save();} }

最終創(chuàng)建好的項目結(jié)構(gòu)如下:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-08T4XESK-1652259021473)(assets/1630033604129.png)]

環(huán)境準(zhǔn)備好后，運行后會發(fā)現(xiàn)有問題

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-8AactOg5-1652259021474)(assets/1630033710052.png)]

出現(xiàn)問題的原因是，在BookServiceImpl類中添加了BookDao的屬性，并提供了setter方法，但是目前是沒有提供配置注入BookDao的，所以bookDao對象為Null,調(diào)用其save方法就會報控指針異常。

3.4.2 注解實現(xiàn)按照類型注入

對于這個問題使用注解該如何解決?

(1) 在BookServiceImpl類的bookDao屬性上添加@Autowired注解

@Service public class BookServiceImpl implements BookService {@Autowiredprivate BookDao bookDao;// public void setBookDao(BookDao bookDao) { // this.bookDao = bookDao; // }public void save() {System.out.println("book service save ...");bookDao.save();} }

注意:

@Autowired可以寫在屬性上，也可也寫在setter方法上，最簡單的處理方式是寫在屬性上并將setter方法刪除掉
為什么setter方法可以刪除呢?
- 自動裝配基于反射設(shè)計創(chuàng)建對象并通過暴力反射為私有屬性進行設(shè)值
- 普通反射只能獲取public修飾的內(nèi)容
- 暴力反射除了獲取public修飾的內(nèi)容還可以獲取private修改的內(nèi)容
- 所以此處無需提供setter方法

(2)@Autowired是按照類型注入，那么對應(yīng)BookDao接口如果有多個實現(xiàn)類，比如添加BookDaoImpl2

@Repository public class BookDaoImpl2 implements BookDao {public void save() {System.out.println("book dao save ...2");} }

這個時候再次運行App，就會報錯

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-WBm1i9MW-1652259021474)(assets/1630034272959.png)]

此時，按照類型注入就無法區(qū)分到底注入哪個對象，解決方案:按照名稱注入

先給兩個Dao類分別起個名稱
@Repository("bookDao") public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ..." );} } @Repository("bookDao2") public class BookDaoImpl2 implements BookDao {public void save() {System.out.println("book dao save ...2" );} }
此時就可以注入成功，但是得思考個問題:
- @Autowired是按照類型注入的，給BookDao的兩個實現(xiàn)起了名稱，它還是有兩個bean對象，為什么不報錯?
- @Autowired默認按照類型自動裝配，如果IOC容器中同類的Bean找到多個，就按照變量名和Bean的名稱匹配。因為變量名叫bookDao而容器中也有一個booDao，所以可以成功注入。
- 分析下面這種情況是否能完成注入呢?
  
  [外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-RCQqqgSs-1652259021475)(assets/1630036236150.png)]
- 不行，因為按照類型會找到多個bean對象，此時會按照bookDao名稱去找，因為IOC容器只有名稱叫bookDao1和bookDao2,所以找不到，會報NoUniqueBeanDefinitionException

3.4.3 注解實現(xiàn)按照名稱注入

當(dāng)根據(jù)類型在容器中找到多個bean,注入?yún)?shù)的屬性名又和容器中bean的名稱不一致，這個時候該如何解決，就需要使用到@Qualifier來指定注入哪個名稱的bean對象。

@Service public class BookServiceImpl implements BookService {@Autowired@Qualifier("bookDao1")private BookDao bookDao;public void save() {System.out.println("book service save ...");bookDao.save();} }

@Qualifier注解后的值就是需要注入的bean的名稱。

注意:@Qualifier不能獨立使用，必須和@Autowired一起使用

3.4.4 簡單數(shù)據(jù)類型注入

引用類型看完，簡單類型注入就比較容易懂了。簡單類型注入的是基本數(shù)據(jù)類型或者字符串類型，下面在BookDaoImpl類中添加一個name屬性，用其進行簡單類型注入

@Repository("bookDao") public class BookDaoImpl implements BookDao {private String name;public void save() {System.out.println("book dao save ..." + name);} }

數(shù)據(jù)類型換了，對應(yīng)的注解也要跟著換，這次使用@Value注解，將值寫入注解的參數(shù)中就行了

@Repository("bookDao") public class BookDaoImpl implements BookDao {@Value("itheima")private String name;public void save() {System.out.println("book dao save ..." + name);} }

注意數(shù)據(jù)格式要匹配，如將"abc"注入給int值，這樣程序就會報錯。

介紹完后，會有一種感覺就是這個注解好像沒什么用，跟直接賦值是一個效果，還沒有直接賦值簡單，所以這個注解存在的意義是什么?

3.4.5 注解讀取properties配置文件

@Value一般會被用在從properties配置文件中讀取內(nèi)容進行使用，具體如何實現(xiàn)?

步驟1：resource下準(zhǔn)備properties文件

jdbc.properties

name=itheima888

步驟2: 使用注解加載properties配置文件

在配置類上添加@PropertySource注解

@Configuration @ComponentScan("com.itheima") @PropertySource("jdbc.properties") public class SpringConfig { }

步驟3：使用@Value讀取配置文件中的內(nèi)容

@Repository("bookDao") public class BookDaoImpl implements BookDao {@Value("${name}")private String name;public void save() {System.out.println("book dao save ..." + name);} }

步驟4:運行程序

運行App類，查看運行結(jié)果，說明配置文件中的內(nèi)容已經(jīng)被加載到

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-M74BWb4A-1652259021476)(assets/1630084683663.png)]

注意:

如果讀取的properties配置文件有多個，可以使用@PropertySource的屬性來指定多個
@PropertySource({"jdbc.properties","xxx.properties"})
@PropertySource注解屬性中不支持使用通配符*,運行會報錯
@PropertySource({"*.properties"})
@PropertySource注解屬性中可以把classpath:加上,代表從當(dāng)前項目的根路徑找文件
@PropertySource({"classpath:jdbc.properties"})

知識點1：@Autowired

名稱@Autowired

類型	屬性注解或方法注解（了解）或方法形參注解（了解）
位置	屬性定義上方或標(biāo)準(zhǔn)set方法上方或類set方法上方或方法形參前面
作用	為引用類型屬性設(shè)置值
屬性	required：true/false，定義該屬性是否允許為null

知識點2：@Qualifier

名稱@Qualifier

類型	屬性注解或方法注解（了解）
位置	屬性定義上方或標(biāo)準(zhǔn)set方法上方或類set方法上方
作用	為引用類型屬性指定注入的beanId
屬性	value（默認）：設(shè)置注入的beanId

知識點3：@Value

名稱@Value

類型	屬性注解或方法注解（了解）
位置	屬性定義上方或標(biāo)準(zhǔn)set方法上方或類set方法上方
作用	為基本數(shù)據(jù)類型或字符串類型屬性設(shè)置值
屬性	value（默認）：要注入的屬性值

知識點4：@PropertySource

名稱@PropertySource

類型	類注解
位置	類定義上方
作用	加載properties文件中的屬性值
屬性	value（默認）：設(shè)置加載的properties文件對應(yīng)的文件名或文件名組成的數(shù)組

4，IOC/DI注解開發(fā)管理第三方bean

前面定義bean的時候都是在自己開發(fā)的類上面寫個注解就完成了，但如果是第三方的類，這些類都是在jar包中，我們沒有辦法在類上面添加注解，這個時候該怎么辦?

遇到上述問題，我們就需要有一種更加靈活的方式來定義bean,這種方式不能在原始代碼上面書寫注解，一樣能定義bean,這就用到了一個全新的注解==@Bean==。

這個注解該如何使用呢?

咱們把之前使用配置方式管理的數(shù)據(jù)源使用注解再來一遍，通過這個案例來學(xué)習(xí)下@Bean的使用。

4.1 環(huán)境準(zhǔn)備

學(xué)習(xí)@Bean注解之前先來準(zhǔn)備環(huán)境:

創(chuàng)建一個Maven項目
pom.xml添加Spring的依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency> </dependencies>
添加一個配置類SpringConfig
@Configuration public class SpringConfig { }
添加BookDao、BookDaoImpl類
public interface BookDao {public void save(); } @Repository public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ..." );} }
創(chuàng)建運行類App
public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);} }

最終創(chuàng)建好的項目結(jié)構(gòu)如下:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-GPik4KQd-1652259021477)(assets/1630122466404.png)]

4.2 注解開發(fā)管理第三方bean

在上述環(huán)境中完成對Druid數(shù)據(jù)源的管理，具體的實現(xiàn)步驟為:

步驟1:導(dǎo)入對應(yīng)的jar包

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.16</version> </dependency>

步驟2:在配置類中添加一個方法

注意該方法的返回值就是要創(chuàng)建的Bean對象類型

@Configuration public class SpringConfig {public DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/spring_db");ds.setUsername("root");ds.setPassword("root");return ds;} }

步驟3:在方法上添加@Bean注解

@Bean注解的作用是將方法的返回值制作為Spring管理的一個bean對象

@Configuration public class SpringConfig {@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/spring_db");ds.setUsername("root");ds.setPassword("root");return ds;} }

注意:不能使用DataSource ds = new DruidDataSource()

因為DataSource接口中沒有對應(yīng)的setter方法來設(shè)置屬性。

步驟4:從IOC容器中獲取對象并打印

public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);DataSource dataSource = ctx.getBean(DataSource.class);System.out.println(dataSource);} }

至此使用@Bean來管理第三方bean的案例就已經(jīng)完成。

如果有多個bean要被Spring管理，直接在配置類中多些幾個方法，方法上添加@Bean注解即可。

4.3 引入外部配置類

如果把所有的第三方bean都配置到Spring的配置類SpringConfig中，雖然可以，但是不利于代碼閱讀和分類管理，所有我們就想能不能按照類別將這些bean配置到不同的配置類中?

對于數(shù)據(jù)源的bean,我們新建一個JdbcConfig配置類，并把數(shù)據(jù)源配置到該類下。

public class JdbcConfig {@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/spring_db");ds.setUsername("root");ds.setPassword("root");return ds;} }

現(xiàn)在的問題是，這個配置類如何能被Spring配置類加載到，并創(chuàng)建DataSource對象在IOC容器中?

針對這個問題，有兩個解決方案:

4.3.1 使用包掃描引入

步驟1:在Spring的配置類上添加包掃描

@Configuration @ComponentScan("com.itheima.config") public class SpringConfig {}

步驟2:在JdbcConfig上添加配置注解

JdbcConfig類要放入到com.itheima.config包下，需要被Spring的配置類掃描到即可

@Configuration public class JdbcConfig {@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/spring_db");ds.setUsername("root");ds.setPassword("root");return ds;} }

步驟3:運行程序

依然能獲取到bean對象并打印控制臺。

這種方式雖然能夠掃描到，但是不能很快的知曉都引入了哪些配置類，所有這種方式不推薦使用。

4.3.2 使用@Import引入

方案一實現(xiàn)起來有點小復(fù)雜，Spring早就想到了這一點，于是又給我們提供了第二種方案。

這種方案可以不用加@Configuration注解，但是必須在Spring配置類上使用@Import注解手動引入需要加載的配置類

步驟1:去除JdbcConfig類上的注解

步驟2:在Spring配置類中引入

@Configuration //@ComponentScan("com.itheima.config") @Import({JdbcConfig.class}) public class SpringConfig {}

注意:

掃描注解可以移除
@Import參數(shù)需要的是一個數(shù)組，可以引入多個配置類。
@Import注解在配置類中只能寫一次，下面的方式是不允許的
@Configuration //@ComponentScan("com.itheima.config") @Import(JdbcConfig.class) @Import(Xxx.class) public class SpringConfig {}

步驟3:運行程序

依然能獲取到bean對象并打印控制臺

知識點1：@Bean

名稱@Bean

類型	方法注解
位置	方法定義上方
作用	設(shè)置該方法的返回值作為spring管理的bean
屬性	value（默認）：定義bean的id

知識點2：@Import

名稱@Import

類型	類注解
位置	類定義上方
作用	導(dǎo)入配置類
屬性	value（默認）：定義導(dǎo)入的配置類類名，當(dāng)配置類有多個時使用數(shù)組格式一次性導(dǎo)入多個配置類

4.4 注解開發(fā)實現(xiàn)為第三方bean注入資源

在使用@Bean創(chuàng)建bean對象的時候，如果方法在創(chuàng)建的過程中需要其他資源該怎么辦?

這些資源會有兩大類，分別是簡單數(shù)據(jù)類型和引用數(shù)據(jù)類型。

4.4.1 簡單數(shù)據(jù)類型

4.4.1.1 需求分析

對于下面代碼關(guān)于數(shù)據(jù)庫的四要素不應(yīng)該寫死在代碼中，應(yīng)該是從properties配置文件中讀取。如何來優(yōu)化下面的代碼?

4.4.1.2 注入簡單數(shù)據(jù)類型步驟

步驟1:類中提供四個屬性

public class JdbcConfig {private String driver;private String url;private String userName;private String password;@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/spring_db");ds.setUsername("root");ds.setPassword("root");return ds;} }

步驟2:使用@Value注解引入值

public class JdbcConfig {@Value("com.mysql.jdbc.Driver")private String driver;@Value("jdbc:mysql://localhost:3306/spring_db")private String url;@Value("root")private String userName;@Value("password")private String password;@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;} }

擴展

現(xiàn)在的數(shù)據(jù)庫連接四要素還是寫在代碼中，需要做的是將這些內(nèi)容提

取到j(luò)dbc.properties配置文件，大家思考下該如何實現(xiàn)?

1.resources目錄下添加jdbc.properties

2.配置文件中提供四個鍵值對分別是數(shù)據(jù)庫的四要素

3.使用@PropertySource加載jdbc.properties配置文件

4.修改@Value注解屬性的值，將其修改為${key}，key就是鍵值對中的鍵的值

具體的實現(xiàn)就交由大家自行實現(xiàn)下。

4.4.2 引用數(shù)據(jù)類型

4.4.2.1 需求分析

假設(shè)在構(gòu)建DataSource對象的時候，需要用到BookDao對象，該如何把BookDao對象注入進方法內(nèi)讓其使用呢?

4.4.2.2 注入引用數(shù)據(jù)類型步驟

步驟1:在SpringConfig中掃描BookDao

掃描的目的是讓Spring能管理到BookDao,也就是說要讓IOC容器中有一個bookDao對象

@Configuration @ComponentScan("com.itheima.dao") @Import({JdbcConfig.class}) public class SpringConfig { }

步驟2:在JdbcConfig類的方法上添加參數(shù)

@Bean public DataSource dataSource(BookDao bookDao){System.out.println(bookDao);DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds; }

引用類型注入只需要為bean定義方法設(shè)置形參即可，容器會根據(jù)類型自動裝配對象。

步驟3:運行程序

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-M0Y4sauv-1652259021478)(assets/1630125475609.png)]

5，注解開發(fā)總結(jié)

前面我們已經(jīng)完成了XML配置和注解的開發(fā)實現(xiàn)，至于兩者之間的差異，咱們放在一塊去對比回顧下:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-TZ20hilB-1652259021480)(assets/1630134786448.png)]

6，Spring整合

課程學(xué)習(xí)到這里，已經(jīng)對Spring有一個簡單的認識了，Spring有一個容器，叫做IoC容器，里面保存bean。在進行企業(yè)級開發(fā)的時候，其實除了將自己寫的類讓Spring管理之外，還有一部分重要的工作就是使用第三方的技術(shù)。前面已經(jīng)講了如何管理第三方bean了，下面結(jié)合IoC和DI，整合2個常用技術(shù)，進一步加深對Spring的使用理解。

6.1 Spring整合Mybatis思路分析

6.1.1 環(huán)境準(zhǔn)備

在準(zhǔn)備環(huán)境的過程中，我們也來回顧下Mybatis開發(fā)的相關(guān)內(nèi)容:

步驟1:準(zhǔn)備數(shù)據(jù)庫表

Mybatis是來操作數(shù)據(jù)庫表，所以先創(chuàng)建一個數(shù)據(jù)庫及表

create database spring_db character set utf8; use spring_db; create table tbl_account(id int primary key auto_increment,name varchar(35),money double );

步驟2:創(chuàng)建項目導(dǎo)入jar包

項目的pom.xml添加相關(guān)依賴

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.16</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.6</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency> </dependencies>

步驟3:根據(jù)表創(chuàng)建模型類

public class Account implements Serializable {private Integer id;private String name;private Double money;//setter...getter...toString...方法略 }

步驟4:創(chuàng)建Dao接口

public interface AccountDao {@Insert("insert into tbl_account(name,money)values(#{name},#{money})")void save(Account account);@Delete("delete from tbl_account where id = #{id} ")void delete(Integer id);@Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")void update(Account account);@Select("select * from tbl_account")List<Account> findAll();@Select("select * from tbl_account where id = #{id} ")Account findById(Integer id); }

步驟5:創(chuàng)建Service接口和實現(xiàn)類

public interface AccountService {void save(Account account);void delete(Integer id);void update(Account account);List<Account> findAll();Account findById(Integer id);}@Service public class AccountServiceImpl implements AccountService {@Autowiredprivate AccountDao accountDao;public void save(Account account) {accountDao.save(account);}public void update(Account account){accountDao.update(account);}public void delete(Integer id) {accountDao.delete(id);}public Account findById(Integer id) {return accountDao.findById(id);}public List<Account> findAll() {return accountDao.findAll();} }

步驟6:添加jdbc.properties文件

resources目錄下添加，用于配置數(shù)據(jù)庫連接四要素

jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false jdbc.username=root jdbc.password=root

useSSL:關(guān)閉MySQL的SSL連接

步驟7:添加Mybatis核心配置文件

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration><properties resource="jdbc.properties"></properties><typeAliases><package name="com.itheima.domain"/></typeAliases><environments default="mysql"><environment id="mysql"><transactionManager type="JDBC"></transactionManager><dataSource type="POOLED"><property name="driver" value="${jdbc.driver}"></property><property name="url" value="${jdbc.url}"></property><property name="username" value="${jdbc.username}"></property><property name="password" value="${jdbc.password}"></property></dataSource></environment></environments><mappers><package name="com.itheima.dao"></package></mappers> </configuration>

步驟8:編寫應(yīng)用程序

public class App {public static void main(String[] args) throws IOException {// 1. 創(chuàng)建SqlSessionFactoryBuilder對象SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();// 2. 加載SqlMapConfig.xml配置文件InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml.bak");// 3. 創(chuàng)建SqlSessionFactory對象SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);// 4. 獲取SqlSessionSqlSession sqlSession = sqlSessionFactory.openSession();// 5. 執(zhí)行SqlSession對象執(zhí)行查詢，獲取結(jié)果UserAccountDao accountDao = sqlSession.getMapper(AccountDao.class);Account ac = accountDao.findById(1);System.out.println(ac);// 6. 釋放資源sqlSession.close();} }

步驟9:運行程序

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-dXTZA1Tp-1652259021481)(assets/1630136904087.png)]

6.1.2 整合思路分析

Mybatis的基礎(chǔ)環(huán)境我們已經(jīng)準(zhǔn)備好了，接下來就得分析下在上述的內(nèi)容中，哪些對象可以交給Spring來管理?

Mybatis程序核心對象分析

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-ZLka9BtG-1652259021482)(assets/1630137189480.png)]

從圖中可以獲取到，真正需要交給Spring管理的是SqlSessionFactory
整合Mybatis，就是將Mybatis用到的內(nèi)容交給Spring管理，分析下配置文件

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-Tb579nEc-1652259021482)(assets/1630137388717.png)]

說明:
- 第一行讀取外部properties配置文件，Spring有提供具體的解決方案@PropertySource,需要交給Spring
- 第二行起別名包掃描，為SqlSessionFactory服務(wù)的，需要交給Spring
- 第三行主要用于做連接池，Spring之前我們已經(jīng)整合了Druid連接池，這塊也需要交給Spring
- 前面三行一起都是為了創(chuàng)建SqlSession對象用的，那么用Spring管理SqlSession對象嗎?回憶下SqlSession是由SqlSessionFactory創(chuàng)建出來的，所以只需要將SqlSessionFactory交給Spring管理即可。
- 第四行是Mapper接口和映射文件[如果使用注解就沒有該映射文件]，這個是在獲取到SqlSession以后執(zhí)行具體操作的時候用，所以它和SqlSessionFactory創(chuàng)建的時機都不在同一個時間，可能需要單獨管理。

6.2 Spring整合Mybatis

前面我們已經(jīng)分析了Spring與Mybatis的整合，大體需要做兩件事，

第一件事是:Spring要管理MyBatis中的SqlSessionFactory

第二件事是:Spring要管理Mapper接口的掃描

具體該如何實現(xiàn)，具體的步驟為:

步驟1:項目中導(dǎo)入整合需要的jar包

<dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.10.RELEASE</version> </dependency> <dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>1.3.0</version> </dependency>

步驟2:創(chuàng)建Spring的主配置類

//配置類注解 @Configuration //包掃描，主要掃描的是項目中的AccountServiceImpl類 @ComponentScan("com.itheima") public class SpringConfig { }

步驟3:創(chuàng)建數(shù)據(jù)源的配置類

在配置類中完成數(shù)據(jù)源的創(chuàng)建

public class JdbcConfig {@Value("${jdbc.driver}")private String driver;@Value("${jdbc.url}")private String url;@Value("${jdbc.username}")private String userName;@Value("${jdbc.password}")private String password;@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;} }

步驟4:主配置類中讀properties并引入數(shù)據(jù)源配置類

@Configuration @ComponentScan("com.itheima") @PropertySource("classpath:jdbc.properties") @Import(JdbcConfig.class) public class SpringConfig { }

步驟5:創(chuàng)建Mybatis配置類并配置SqlSessionFactory

public class MybatisConfig {//定義bean，SqlSessionFactoryBean，用于產(chǎn)生SqlSessionFactory對象@Beanpublic SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();//設(shè)置模型類的別名掃描ssfb.setTypeAliasesPackage("com.itheima.domain");//設(shè)置數(shù)據(jù)源ssfb.setDataSource(dataSource);return ssfb;}//定義bean，返回MapperScannerConfigurer對象@Beanpublic MapperScannerConfigurer mapperScannerConfigurer(){MapperScannerConfigurer msc = new MapperScannerConfigurer();msc.setBasePackage("com.itheima.dao");return msc;} }

說明:

使用SqlSessionFactoryBean封裝SqlSessionFactory需要的環(huán)境信息

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-r5BgeTay-1652259021483)(assets/1630138835057.png)]
- SqlSessionFactoryBean是前面我們講解FactoryBean的一個子類，在該類中將SqlSessionFactory的創(chuàng)建進行了封裝，簡化對象的創(chuàng)建，我們只需要將其需要的內(nèi)容設(shè)置即可。
- 方法中有一個參數(shù)為dataSource,當(dāng)前Spring容器中已經(jīng)創(chuàng)建了Druid數(shù)據(jù)源，類型剛好是DataSource類型，此時在初始化SqlSessionFactoryBean這個對象的時候，發(fā)現(xiàn)需要使用DataSource對象，而容器中剛好有這么一個對象，就自動加載了DruidDataSource對象。
使用MapperScannerConfigurer加載Dao接口，創(chuàng)建代理對象保存到IOC容器中

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-OHYtXYzz-1652259021484)(assets/1630138916939.png)]
- 這個MapperScannerConfigurer對象也是MyBatis提供的專用于整合的jar包中的類，用來處理原始配置文件中的mappers相關(guān)配置，加載數(shù)據(jù)層的Mapper接口類
- MapperScannerConfigurer有一個核心屬性basePackage，就是用來設(shè)置所掃描的包路徑

步驟6:主配置類中引入Mybatis配置類

@Configuration @ComponentScan("com.itheima") @PropertySource("classpath:jdbc.properties") @Import({JdbcConfig.class,MybatisConfig.class}) public class SpringConfig { }

步驟7:編寫運行類

在運行類中，從IOC容器中獲取Service對象，調(diào)用方法獲取結(jié)果

public class App2 {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);AccountService accountService = ctx.getBean(AccountService.class);Account ac = accountService.findById(1);System.out.println(ac);} }

步驟8:運行程序

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-dzpn82aC-1652259021484)(assets/1630139036627.png)]

支持Spring與Mybatis的整合就已經(jīng)完成了，其中主要用到的兩個類分別是:

SqlSessionFactoryBean
MapperScannerConfigurer

6.3 Spring整合Junit

整合Junit與整合Druid和MyBatis差異比較大，為什么呢？Junit是一個搞單元測試用的工具，它不是我們程序的主體，也不會參加最終程序的運行，從作用上來說就和之前的東西不一樣，它不是做功能的，看做是一個輔助工具就可以了。

6.3.1 環(huán)境準(zhǔn)備

這塊環(huán)境，大家可以直接使用Spring與Mybatis整合的環(huán)境即可。當(dāng)然也可以重新創(chuàng)建一個，因為內(nèi)容是一模一樣，所以我們直接來看下項目結(jié)構(gòu)即可:

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-Dirf0ONL-1652259021485)(assets/1630139720273.png)]

6.3.2 整合Junit步驟

在上述環(huán)境的基礎(chǔ)上，我們來對Junit進行整合。

步驟1:引入依賴

pom.xml

<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope> </dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.2.10.RELEASE</version> </dependency>

步驟2:編寫測試類

在test\java下創(chuàng)建一個AccountServiceTest,這個名字任意

//設(shè)置類運行器 @RunWith(SpringJUnit4ClassRunner.class) //設(shè)置Spring環(huán)境對應(yīng)的配置類 @ContextConfiguration(classes = {SpringConfiguration.class}) //加載配置類 //@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加載配置文件 public class AccountServiceTest {//支持自動裝配注入bean@Autowiredprivate AccountService accountService;@Testpublic void testFindById(){System.out.println(accountService.findById(1));}@Testpublic void testFindAll(){System.out.println(accountService.findAll());} }

注意:

單元測試，如果測試的是注解配置類，則使用@ContextConfiguration(classes = 配置類.class)
單元測試，如果測試的是配置文件，則使用@ContextConfiguration(locations={配置文件名,...})
Junit運行后是基于Spring環(huán)境運行的，所以Spring提供了一個專用的類運行器，這個務(wù)必要設(shè)置，這個類運行器就在Spring的測試專用包中提供的，導(dǎo)入的坐標(biāo)就是這個東西SpringJUnit4ClassRunner
上面兩個配置都是固定格式，當(dāng)需要測試哪個bean時，使用自動裝配加載對應(yīng)的對象，下面的工作就和以前做Junit單元測試完全一樣了

知識點1：@RunWith

名稱@RunWith

類型	測試類注解
位置	測試類定義上方
作用	設(shè)置JUnit運行器
屬性	value（默認）：運行所使用的運行期

知識點2：@ContextConfiguration

名稱@ContextConfiguration

類型	測試類注解
位置	測試類定義上方
作用	設(shè)置JUnit加載的Spring核心配置
屬性	classes：核心配置類，可以使用數(shù)組的格式設(shè)定加載多個配置類 locations:配置文件，可以使用數(shù)組的格式設(shè)定加載多個配置文件名稱

總結(jié)

以上是生活随笔為你收集整理的Spring_day02的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。