當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

Spring_day02

發布時間：2024/3/24 javascript 43 豆豆

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

Spring_day02

今日目標

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

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

前面所講的知識點都是基于我們自己寫的類，現在如果有需求讓我們去管理第三方jar包中的類，該如何管理?

1.1 案例:數據源對象管理

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

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

1.1.1 環境準備

學習之前，先來準備下案例環境:

創建一個Maven項目

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(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 思路分析

在上述環境下，我們來對數據源進行配置管理，先來分析下思路:

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

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

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

3.數據庫連接需要基礎的四要素驅動、連接、用戶名和密碼，【如何注入】到對應的bean中

4.從IOC容器中獲取對應的bean對象，將其打印到控制臺查看結果

思考:

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

1.1.3 實現Druid管理

帶著這兩個問題，把下面的案例實現下:

步驟1:導入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:數據庫驅動
url:數據庫連接地址
username:數據庫連接用戶名
password:數據庫連接密碼
數據庫連接的四要素要和自己使用的數據庫信息一致。

步驟3:從IOC容器中獲取對應的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:運行程序

打印如下結果: 說明第三方bean對象已經被spring的IOC容器進行管理

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

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

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

1.1.4 實現C3P0管理

完成了DruidDataSource的管理，接下來我們再來加深下練習，這次我們來管理C3P0數據源，具體的實現步驟是什么呢?

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

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

步驟1:導入C3P0的依賴

pom.xml中添加依賴

對于新的技術，不知道具體的坐標該如何查找?

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

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

步驟2:配置第三方bean

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

注意:

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

步驟3:運行程序

程序會報錯，錯誤如下

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

報的錯為ClassNotFoundException,翻譯出來是類沒有發現的異常，具體的類為com.mysql.jdbc.Driver。錯誤的原因是缺少mysql的驅動包。

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

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

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

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

注意：

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

1.2 加載properties文件

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

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

問題提出來后，具體該如何實現?

1.2.1 第三方bean屬性優化

1.2.1.1 實現思路

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

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

2.將數據庫連接四要素配置到配置文件中

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

4.使用加載到的值實現屬性注入

其中第3，4步驟是需要大家重點關注，具體是如何實現。

1.2.1.2 實現步驟

步驟1:準備properties配置文件

resources下創建一個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

步驟2:開啟context命名空間

在applicationContext.xml中開context命名空間

步驟3:加載properties配置文件

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

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

步驟4:完成屬性注入

使用${key}來讀取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="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配置文件中的內容就已經完成。

1.2.2 讀取單個屬性

1.2.2.1 實現思路

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

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

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

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

3.在jdbc.properties中添加數據注入到bookDao中打印方便查詢結果

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

1.2.2.2 實現步驟

步驟1:在項目中添對應的類

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對象，調用方法，查看值是否已經被獲取到并打印控制臺

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();} }

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

1.2.2.3 注意事項

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

問題一:鍵值對的key為username引發的問題

1.在properties中配置鍵值對的時候，如果key設置為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，而是自己電腦的用戶名

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

4.出現問題的原因是<context:property-placeholder/>標簽會加載系統的環境變量，而且環境變量的值會被優先加載，如何查看系統的環境變量?
public static void main(String[] args) throws Exception{Map<String, String> env = System.getenv();System.out.println(env); }
大家可以自行運行，在打印出來的結果中會有一個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:設置為NEVER,表示不加載系統屬性，就可以解決上述問題。

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

1.調整下配置文件的內容，在resources下添加jdbc.properties,jdbc2.properties,內容如下:

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>
說明:
- 方式一:可以實現，如果配置文件多的話，每個都需要配置
- 方式二:*.properties代表所有以properties結尾的文件都會被加載，可以解決方式一的問題，但是不標準
- 方式三:標準的寫法，classpath:代表的是從根路徑下開始查找，但是只能查詢當前項目的根路徑
- 方式四:不僅可以加載當前項目還可以加載當前項目所依賴的所有項目的根路徑下的properties配置文件

1.2.3 加載properties文件小結

本節主要講解的是properties配置文件的加載，需要掌握的內容有:

如何開啟context命名空間

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

2，核心容器

前面已經完成bean與依賴注入的相關知識學習，接下來我們主要學習的是IOC容器中的核心容器。

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

如何創建容器?
創建好容器后，如何從容器中獲取bean對象?
容器類的層次結構是什么?
BeanFactory是什么?

2.1 環境準備

在學習和解決上述問題之前，先來準備下案例環境:

創建一個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 ..." );} }
創建運行類App
public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();} }

最終創建好的項目結構如下:

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

2.2 容器

2.2.1 容器的創建方式

案例中創建ApplicationContext的方式為:

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

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

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

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

這種方式翻譯為:文件系統下的XML配置文件

使用這種方式，運行，會出現如下錯誤:

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

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

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

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

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

2.2.2 Bean的三種獲取方式

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

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

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

方式二：

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

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

方式三:

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

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

2.2.3 容器類層次結構

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

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

(2)點擊進入BeanFactory類，ctrl+h,就能查看到如下結構的層次關系

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

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

2.2.4 BeanFactory的使用

使用BeanFactory來創建IOC容器的具體實現方式為:

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之間的區別，在BookDaoImpl添加如下構造函數:

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

如果不去獲取bean對象，打印會發現：

BeanFactory是延遲加載，只有在獲取bean對象的時候才會去創建
ApplicationContext是立即加載，容器加載的時候就會創建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>

小結

這一節中所講的知識點包括:

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

2.2 核心容器總結

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

2.2.1 容器相關

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

2.2.2 bean相關

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

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

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

2.2.3 依賴注入相關

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

3，IOC/DI注解開發

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

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

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

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

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

關于注解開發，我們會講解兩塊內容注解開發定義bean和純注解開發。

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

3.1 環境準備

在學習注解開發之前，先來準備下案例環境:

創建一個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 ...");} }
創建運行類App
public class App {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();} }

最終創建好的項目結構如下:

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

3.2 注解開發定義bean

在上述環境的基礎上，我們來學一學Spring是如何通過注解實現bean的定義開發?

步驟1:刪除原XML配置

將配置文件中的<bean>標簽刪除掉

步驟2:Dao上添加注解

在BookDaoImpl類上添加@Component注解

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

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

XML與注解配置的對應關系:

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(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類查看打印結果

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(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對應的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);} }

打印觀察結果，兩個bean對象都已經打印到控制臺

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

說明:

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

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

通過查看源碼會發現:

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

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

方便我們后期在編寫類的時候能很好的區分出這個類是屬于表現層、業務層還是數據層的類。

知識點1:@Component等

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

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

3.2 純注解開發模式

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

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

具體如何實現?

3.2.1 思路分析

實現思路為:

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

3.2.2 實現步驟

步驟1:創建配置類

創建一個配置類SpringConfig

public class SpringConfig { }

步驟2:標識該類為配置類

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

@Configuration public class SpringConfig { }

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

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

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

步驟4:創建運行類并執行

創建一個新的運行類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,可以看到兩個對象依然被獲取成功

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

至此，純注解開發的方式就已經完成了，主要內容包括:

Java類替換Spring核心配置文件

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

知識點1：@Configuration

名稱@Configuration

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

知識點2：@ComponentScan

名稱@ComponentScan

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

小結:

這一節重點掌握的是使用注解完成Spring的bean管理，需要掌握的內容為:

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

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

使用注解已經完成了bean的管理，接下來按照前面所學習的內容，將通過配置實現的內容都換成對應的注解實現，包含兩部分內容:bean作用范圍和bean生命周期。

3.3.1 環境準備

老規矩，學習之前先來準備環境:

創建一個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 ..." );} }
創建運行類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);} }

最終創建好的項目結構如下:

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

3.3.2 Bean的作用范圍

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

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

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

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

再次執行App類，打印結果:

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

知識點1：@Scope

名稱@Scope

類型	類注解
位置	類定義上方
作用	設置該類創建對象的作用范圍可用于設置創建出的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)如何對方法進行標識，哪個是初始化方法，哪個是銷毀方法?

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

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

(3)要想看到兩個方法執行，需要注意的是destroy只有在容器關閉的時候，才會執行，所以需要修改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(); //關閉容器} }

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

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

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

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

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

知識點1：@PostConstruct

名稱@PostConstruct

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

知識點2：@PreDestroy

名稱@PreDestroy

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

小結

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

3.4 注解開發依賴注入

Spring為了使用注解簡化開發，并沒有提供構造函數注入、setter注入對應的注解，只提供了自動裝配的注解實現。

3.4.1 環境準備

在學習之前，把案例環境介紹下:

創建一個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();} }
創建運行類App
public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookService bookService = ctx.getBean(BookService.class);bookService.save();} }

最終創建好的項目結構如下:

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

環境準備好后，運行后會發現有問題

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

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

3.4.2 注解實現按照類型注入

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

(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方法可以刪除呢?
- 自動裝配基于反射設計創建對象并通過暴力反射為私有屬性進行設值
- 普通反射只能獲取public修飾的內容
- 暴力反射除了獲取public修飾的內容還可以獲取private修改的內容
- 所以此處無需提供setter方法

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

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

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

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

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

先給兩個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的兩個實現起了名稱，它還是有兩個bean對象，為什么不報錯?
- @Autowired默認按照類型自動裝配，如果IOC容器中同類的Bean找到多個，就按照變量名和Bean的名稱匹配。因為變量名叫bookDao而容器中也有一個booDao，所以可以成功注入。
- 分析下面這種情況是否能完成注入呢?
  
  [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-RCQqqgSs-1652259021475)(assets/1630036236150.png)]
- 不行，因為按照類型會找到多個bean對象，此時會按照bookDao名稱去找，因為IOC容器只有名稱叫bookDao1和bookDao2,所以找不到，會報NoUniqueBeanDefinitionException

3.4.3 注解實現按照名稱注入

當根據類型在容器中找到多個bean,注入參數的屬性名又和容器中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 簡單數據類型注入

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

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

數據類型換了，對應的注解也要跟著換，這次使用@Value注解，將值寫入注解的參數中就行了

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

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

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

3.4.5 注解讀取properties配置文件

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

步驟1：resource下準備properties文件

jdbc.properties

name=itheima888

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

在配置類上添加@PropertySource注解

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

步驟3：使用@Value讀取配置文件中的內容

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

步驟4:運行程序

運行App類，查看運行結果，說明配置文件中的內容已經被加載到

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

注意:

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

知識點1：@Autowired

名稱@Autowired

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

知識點2：@Qualifier

名稱@Qualifier

類型	屬性注解或方法注解（了解）
位置	屬性定義上方或標準set方法上方或類set方法上方
作用	為引用類型屬性指定注入的beanId
屬性	value（默認）：設置注入的beanId

知識點3：@Value

名稱@Value

類型	屬性注解或方法注解（了解）
位置	屬性定義上方或標準set方法上方或類set方法上方
作用	為基本數據類型或字符串類型屬性設置值
屬性	value（默認）：要注入的屬性值

知識點4：@PropertySource

名稱@PropertySource

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

4，IOC/DI注解開發管理第三方bean

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

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

這個注解該如何使用呢?

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

4.1 環境準備

學習@Bean注解之前先來準備環境:

創建一個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 ..." );} }
創建運行類App
public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);} }

最終創建好的項目結構如下:

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

4.2 注解開發管理第三方bean

在上述環境中完成對Druid數據源的管理，具體的實現步驟為:

步驟1:導入對應的jar包

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

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

注意該方法的返回值就是要創建的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接口中沒有對應的setter方法來設置屬性。

步驟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的案例就已經完成。

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

4.3 引入外部配置類

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

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

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

現在的問題是，這個配置類如何能被Spring配置類加載到，并創建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引入

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

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

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

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

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

注意:

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

步驟3:運行程序

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

知識點1：@Bean

名稱@Bean

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

知識點2：@Import

名稱@Import

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

4.4 注解開發實現為第三方bean注入資源

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

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

4.4.1 簡單數據類型

4.4.1.1 需求分析

對于下面代碼關于數據庫的四要素不應該寫死在代碼中，應該是從properties配置文件中讀取。如何來優化下面的代碼?

4.4.1.2 注入簡單數據類型步驟

步驟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;} }

擴展

現在的數據庫連接四要素還是寫在代碼中，需要做的是將這些內容提

取到jdbc.properties配置文件，大家思考下該如何實現?

1.resources目錄下添加jdbc.properties

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

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

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

具體的實現就交由大家自行實現下。

4.4.2 引用數據類型

4.4.2.1 需求分析

假設在構建DataSource對象的時候，需要用到BookDao對象，該如何把BookDao對象注入進方法內讓其使用呢?

4.4.2.2 注入引用數據類型步驟

步驟1:在SpringConfig中掃描BookDao

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

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

步驟2:在JdbcConfig類的方法上添加參數

@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定義方法設置形參即可，容器會根據類型自動裝配對象。

步驟3:運行程序

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

5，注解開發總結

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

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

6，Spring整合

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

6.1 Spring整合Mybatis思路分析

6.1.1 環境準備

在準備環境的過程中，我們也來回顧下Mybatis開發的相關內容:

步驟1:準備數據庫表

Mybatis是來操作數據庫表，所以先創建一個數據庫及表

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:創建項目導入jar包

項目的pom.xml添加相關依賴

<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:根據表創建模型類

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

步驟4:創建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:創建Service接口和實現類

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目錄下添加，用于配置數據庫連接四要素

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

useSSL:關閉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:編寫應用程序

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

步驟9:運行程序

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

6.1.2 整合思路分析

Mybatis的基礎環境我們已經準備好了，接下來就得分析下在上述的內容中，哪些對象可以交給Spring來管理?

Mybatis程序核心對象分析

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

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

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

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

6.2 Spring整合Mybatis

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

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

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

具體該如何實現，具體的步驟為:

步驟1:項目中導入整合需要的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:創建Spring的主配置類

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

步驟3:創建數據源的配置類

在配置類中完成數據源的創建

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并引入數據源配置類

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

步驟5:創建Mybatis配置類并配置SqlSessionFactory

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

說明:

使用SqlSessionFactoryBean封裝SqlSessionFactory需要的環境信息

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

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

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

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

步驟7:編寫運行類

在運行類中，從IOC容器中獲取Service對象，調用方法獲取結果

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:運行程序

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

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

SqlSessionFactoryBean
MapperScannerConfigurer

6.3 Spring整合Junit

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

6.3.1 環境準備

這塊環境，大家可以直接使用Spring與Mybatis整合的環境即可。當然也可以重新創建一個，因為內容是一模一樣，所以我們直接來看下項目結構即可:

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

6.3.2 整合Junit步驟

在上述環境的基礎上，我們來對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下創建一個AccountServiceTest,這個名字任意

//設置類運行器 @RunWith(SpringJUnit4ClassRunner.class) //設置Spring環境對應的配置類 @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環境運行的，所以Spring提供了一個專用的類運行器，這個務必要設置，這個類運行器就在Spring的測試專用包中提供的，導入的坐標就是這個東西SpringJUnit4ClassRunner
上面兩個配置都是固定格式，當需要測試哪個bean時，使用自動裝配加載對應的對象，下面的工作就和以前做Junit單元測試完全一樣了

知識點1：@RunWith

名稱@RunWith

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

知識點2：@ContextConfiguration

名稱@ContextConfiguration

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

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：窄带物联网NB-IOT
下一篇： gradle idea java ssm