`JDBC` = `Java Database Connectivity`,顧名思義:它的做用是進行數據庫連接的。在`Spring`中,提供`JDBC` 功能的是`JdbcTemplate`,我們可以在項目中直接使用`JdbcTemplate`來進行關系型數據庫的連接。
## 實始化
在使用`Spring`自帶一些功能模塊時,我們一般需要經過聲明變量及添加`Autowired`注解兩步操作:
TeacherController
```java
import org.springframework.jdbc.core.JdbcTemplate;
@RestController
@RequestMapping("Teacher")
public class TeacherController {
@Autowired // ?
JdbcTemplate jdbcTemplate; // ?
```
* ? 聲明變量名稱及變量類型。
* ? 添加注解。`Spring`在掃描到該注解時,將自動向`TeacherController`注入一個符合要求的對象(這個對象又習慣性的稱為Bean)
為了在后臺的控制臺中更方便的打印一些信息,我們加入用于打印日志的對象:
```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
@RestController
@RequestMapping("Teacher")
public class TeacherController {
private final static Logger logger = LoggerFactory.getLogger(TeacherController.class.getName());
@Autowired
JdbcTemplate jdbcTemplate;
```
## 查詢數據
`JdbcTemplate`提供了`query()`方法,[該方法](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/jdbc/core/JdbcTemplate.html)接收的參數較多,使用起來也比較靈活。在此我們使用較簡單的一種[較簡單的一種](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/jdbc/core/JdbcTemplate.html#query-java.lang.String-org.springframework.jdbc.core.RowCallbackHandler-),即:
```
public void? query(String sql,
RowCallbackHandler rch)
throws DataAccessException
Description copied from interface: JdbcOperations
Execute a query given static SQL, reading the ResultSet on a per-row basis with a RowCallbackHandler.
Uses a JDBC Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded query method with null as argument array.
Specified by:
query in interface JdbcOperations
Parameters:
參數:
sql - the SQL query to execute
sql - 執行的SQL查詢語句 ?
rch - a callback that will extract results, one row at a time
rch - 一個用于提取結果的回調,每次一行數據 ?
Throws:
DataAccessException - if there is any problem executing the query
See Also:
JdbcOperations.query(String, Object[], RowCallbackHandler)
```
由`API`文檔我們可以看出:
? 該方法沒有返回值。
? 執行的`sql`語句放這里。
? 一個類似于回調函數(確切的說是一個回調對象,在進行回調時,調用了該對象特定的方法)的設計,查詢完畢后,將查詢的結果放這里。
參數`RowCallbackHandler`[傳送門](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/jdbc/core/RowCallbackHandler.html)是一個接口。為了滿足`query`方法的需求,我們首先需要實例化一個實現了`RowCallbackHandler`接口的對象出來。其實這更貼近于現實生活,比如我們郵寄快遞后,并不關心是哪個快遞員來給我們送快遞,我們關心是快遞員擁有送快遞的功能。此時假設`query`用于提出了郵快遞的要求,它接收的第二個參數`RowCallbackHandler`要求有快遞的功能,我們為了滿足`query`的要求,此時需要實例化一個滿足其要求的快遞員出來。在`JAVA`中,我們用如下代碼來快速的實例化一個實現某接口的對象。我們將原來的`getAll`方法刪除后重寫一個新的`getAll`方法如下:
TeacherController -> getAll
```
import org.springframework.jdbc.core.RowCallbackHandler;
import java.sql.ResultSet;
import java.sql.SQLException;
@GetMapping
public void getAll() {
RowCallbackHandler rowCallbackHandler = new RowCallbackHandler() { //?
@Override // ?
public void processRow(ResultSet resultSet) throws SQLException { // ?
logger.info("處理的結果是:" + resultSet.toString());
}
};
}
```
? 實例化對象`rowCallbackHandler`,該對象的類型為:`RowCallbackHandler`
? Override接口`RowCallbackHandler`中的方法(實現某個接口,必須實現其中的所有方法)
? 將`rowCallbackHandler`傳入`query()`中,將進行調用的默認方法。
有了這個對象,若想調用`JdbcTemplate.query()`方法就簡單了:
```java
@GetMapping
public void getAll() {
/* 定義實現了RowCallbackHandler接口的對象*/
RowCallbackHandler rowCallbackHandler = new RowCallbackHandler() {
/**
* 該方法用于執行jdbcTemplate.query后的回調,每行數據回調1次。比如Teacher表中有兩行數據,則回調此方法兩次。
* @param resultSet 查詢結果,每次一行
* @throws SQLException 查詢出錯時,將拋出此異常,暫時不處理。
*/
@Override
public void processRow(ResultSet resultSet) throws SQLException {
logger.info("處理的結果是:" + resultSet.toString());
}
};
/*定義查詢字符串*/
String query = "select id, name, sex, username, email, create_time, update_time from teacher";
/*使用query進行查詢,并把查詢的結果通過調用rowCallbackHandler.processRow()方法傳遞給rowCallbackHandler對象*/
jdbcTemplate.query(query, rowCallbackHandler);
}
```
## 測試
最后我們進行核心的測試環節。
首先,我們在IDEA中打個斷點:

然后使用`debug`模式來啟動項目:

最后打開瀏覽器,并輸入`http://localhost:8080/Teacher`,此時IDEA將自動停留在斷點處,并我們打開了`debug`控制臺。讓我們詳細的看一下返回的數據格式:

依次點擊:
`resultSet -> statement -> delegate -> results -> rowDate -> rows -> 0 -> internalRowData -> 0`

我們發現返回的數據的存儲格式全部為`byte`數組,這是由于數據的最小存儲及處理單元就是`byte`,即字節。每個字節由8個二進制位組成,也就是我們常說的1byte = 8bit。所以該字節存的無符號數最大值為:255(1111 1111),最小值為:0(0000 0000);有符號數最大值為:127 (0111 1111),最小值為:-128(1000 0000)。如上圖示,我們在`internalRowData`的第0行第0列數據的值是49,但我們知道我們在數據庫中第0行應該是張三對應的數據,第0行的第0列應該是張三的ID,即1。那么為什么是49呢?這就涉及到了前面講的編碼知識了。在數據庫中,bigint的字符介于0-9之間,所以編碼就是簡單的`asscii`。參考ascii編碼表[ascii編碼表](https://ascii.cl/) 49對應的正是1。

然后我們再查看第0行,第1列。

我們將前三個字節轉換為16進制后:

然后再來到[fileformat](https://www.fileformat.info/info/unicode/char/5f20/index.htm)

沒錯,正如你所見的一樣。無論是bigint還是字符串、tinyint,反映到數據傳輸的底層,都是2進制!為了進一步驗證我們的觀點,將其轉換為2進制進行查看:


> **注意:** 上述過程僅為帶領大家更好的認識基本數據,現在我們并不需要掌握。
# 完成查詢
底層的東西通過實踐弄明白以后,表層的東西就是讀`api`加經驗談了。我們的目標是將數據表中的數據,轉換為可以被前臺接收的json字符串。`spring`又貼心的提供了將對象直接轉換為json字符串的能力。所以我們下面只需要建立建立Teacher模型以及返回Teacher數組即可:
## 建立模型
Teacher
```
package com.mengyunzhi.springBootStudy;
/**
* 教師模型,用于更方便的存儲查表后返回的數據
*/
public class Teacher {
private Long id;
private String name;
private Boolean sex;
private String username;
private String email;
private Long createTime;
private Long updateTime;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Boolean getSex() {
return sex;
}
public void setSex(Boolean sex) {
this.sex = sex;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Long getCreateTime() {
return createTime;
}
public void setCreateTime(Long createTime) {
this.createTime = createTime;
}
public Long getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Long updateTime) {
this.updateTime = updateTime;
}
}
```
## 返回數組
返回初始化及改變返回值類型
```java
import java.util.ArrayList;
import java.util.List;
@GetMapping
public List<Teacher> getAll() { ?
/*初始化不固定大小的數組*/
List<Teacher> teachers = new ArrayList<>(); ?
```
* ? 返回值類型是個列表`List`,該列表中的每一項的類型是`Teacher`。
* ? `List`是接口,說明了自己的需求,想要一個擁有`List`中規定的功能的對象,至于這個對象是誰不重要。實例化`ArrayList`得到滿足`List`功能需求的對象。
```java
@GetMapping
public List<Teacher> getAll() {
/*初始化不固定大小的數組*/
List<Teacher> teachers = new ArrayList<>();
/* 定義實現了RowCallbackHandler接口的對象*/
RowCallbackHandler rowCallbackHandler = new RowCallbackHandler() {
/**
* 該方法用于執行jdbcTemplate.query后的回調,每行數據回調1次。比如Teacher表中有兩行數據,則回調此方法兩次。
*
* @param resultSet 查詢結果,每次一行
* @throws SQLException 查詢出錯時,將拋出此異常,暫時不處理。
*/
@Override
public void processRow(ResultSet resultSet) throws SQLException {
Teacher teacher = new Teacher();
/*獲取字段id,并轉換為Long類型返回*/
teacher.setId(resultSet.getLong("id"));
/*獲取字段name,并轉換為String類型返回*/
teacher.setName(resultSet.getString("name"));
/*獲取字段sex,并轉換為布爾類型返回*/
teacher.setSex(resultSet.getBoolean("sex"));
teacher.setUsername(resultSet.getString("username"));
teacher.setEmail(resultSet.getString("email"));
teacher.setCreateTime(resultSet.getLong("create_time"));
teacher.setUpdateTime(resultSet.getLong("update_time"));
/*將得到的teacher添加到要返回的數組中*/
teachers.add(teacher);
}
};
/*定義查詢字符串*/
String query = "select id, name, sex, username, email, create_time, update_time from teacher";
/*使用query進行查詢,并把查詢的結果通過調用rowCallbackHandler.processRow()方法傳遞給rowCallbackHandler對象*/
jdbcTemplate.query(query, rowCallbackHandler);
return teachers;
}
```
## 測試
重新啟動項目,并測試:

# 本節小測
一起猜猜看,我們前面講過`utf8mb4`編碼存儲內容時,每個字符需要4個字節的存儲空間。那么請問:為什么存`張三`這兩個字符時,占用的存儲空間是6個字節,而不是8個字節呢
# 參考文檔
| 名稱 | 鏈接 | 預計學習時長(分) |
| --- | --- | --- |
| Accessing Relational Data using JDBC with Spring | [https://spring.io/guides/gs/relational-data-access/](https://spring.io/guides/gs/relational-data-access/) | 15 |
| ascii編碼表 | [https://ascii.cl/](https://ascii.cl/) | 2 |
| 張字的UTF8碼 | [https://www.fileformat.info/info/unicode/char/5f20/index.htm](https://www.fileformat.info/info/unicode/char/5f20/index.htm) | \- |
| 三字的UTF8碼 | [https://www.fileformat.info/info/unicode/char/4e09/index.htm](https://www.fileformat.info/info/unicode/char/4e09/index.htm) | 2 |
| JdbcTemplate | [https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/jdbc/core/JdbcTemplate.html](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/jdbc/core/JdbcTemplate.html) | 10 |
| RowCallbackHandler | [https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/jdbc/core/RowCallbackHandler.html](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/jdbc/core/RowCallbackHandler.html) | 5 |
| List與ArrayList | [https://zhuanlan.zhihu.com/p/25392526](https://zhuanlan.zhihu.com/p/25392526) | 10 |
| list vs arrayList | [https://techdifferences.com/difference-between-list-and-arraylist-in-java.html](https://techdifferences.com/difference-between-list-and-arraylist-in-java.html) | 10 |
| Anonymous Classes in Java | [https://www.baeldung.com/java-anonymous-classes](https://www.baeldung.com/java-anonymous-classes) | 20 |
| 源碼 | https://github.com/mengyunzhi/spring-boot-and-angular-guild/releases/tag/step2.2.3 | - |
- 序言
- 第一章:Hello World
- 第一節:Angular準備工作
- 1 Node.js
- 2 npm
- 3 WebStorm
- 第二節:Hello Angular
- 第三節:Spring Boot準備工作
- 1 JDK
- 2 MAVEN
- 3 IDEA
- 第四節:Hello Spring Boot
- 1 Spring Initializr
- 2 Hello Spring Boot!
- 3 maven國內源配置
- 4 package與import
- 第五節:Hello Spring Boot + Angular
- 1 依賴注入【前】
- 2 HttpClient獲取數據【前】
- 3 數據綁定【前】
- 4 回調函數【選學】
- 第二章 教師管理
- 第一節 數據庫初始化
- 第二節 CRUD之R查數據
- 1 原型初始化【前】
- 2 連接數據庫【后】
- 3 使用JDBC讀取數據【后】
- 4 前后臺對接
- 5 ng-if【前】
- 6 日期管道【前】
- 第三節 CRUD之C增數據
- 1 新建組件并映射路由【前】
- 2 模板驅動表單【前】
- 3 httpClient post請求【前】
- 4 保存數據【后】
- 5 組件間調用【前】
- 第四節 CRUD之U改數據
- 1 路由參數【前】
- 2 請求映射【后】
- 3 前后臺對接【前】
- 4 更新數據【前】
- 5 更新某個教師【后】
- 6 路由器鏈接【前】
- 7 觀察者模式【前】
- 第五節 CRUD之D刪數據
- 1 綁定到用戶輸入事件【前】
- 2 刪除某個教師【后】
- 第六節 代碼重構
- 1 文件夾化【前】
- 2 優化交互體驗【前】
- 3 相對與絕對地址【前】
- 第三章 班級管理
- 第一節 JPA初始化數據表
- 第二節 班級列表
- 1 新建模塊【前】
- 2 初識單元測試【前】
- 3 初始化原型【前】
- 4 面向對象【前】
- 5 測試HTTP請求【前】
- 6 測試INPUT【前】
- 7 測試BUTTON【前】
- 8 @RequestParam【后】
- 9 Repository【后】
- 10 前后臺對接【前】
- 第三節 新增班級
- 1 初始化【前】
- 2 響應式表單【前】
- 3 測試POST請求【前】
- 4 JPA插入數據【后】
- 5 單元測試【后】
- 6 惰性加載【前】
- 7 對接【前】
- 第四節 編輯班級
- 1 FormGroup【前】
- 2 x、[x]、{{x}}與(x)【前】
- 3 模擬路由服務【前】
- 4 測試間諜spy【前】
- 5 使用JPA更新數據【后】
- 6 分層開發【后】
- 7 前后臺對接
- 8 深入imports【前】
- 9 深入exports【前】
- 第五節 選擇教師組件
- 1 初始化【前】
- 2 動態數據綁定【前】
- 3 初識泛型
- 4 @Output()【前】
- 5 @Input()【前】
- 6 再識單元測試【前】
- 7 其它問題
- 第六節 刪除班級
- 1 TDD【前】
- 2 TDD【后】
- 3 前后臺對接
- 第四章 學生管理
- 第一節 引入Bootstrap【前】
- 第二節 NAV導航組件【前】
- 1 初始化
- 2 Bootstrap格式化
- 3 RouterLinkActive
- 第三節 footer組件【前】
- 第四節 歡迎界面【前】
- 第五節 新增學生
- 1 初始化【前】
- 2 選擇班級組件【前】
- 3 復用選擇組件【前】
- 4 完善功能【前】
- 5 MVC【前】
- 6 非NULL校驗【后】
- 7 唯一性校驗【后】
- 8 @PrePersist【后】
- 9 CM層開發【后】
- 10 集成測試
- 第六節 學生列表
- 1 分頁【后】
- 2 HashMap與LinkedHashMap
- 3 初識綜合查詢【后】
- 4 綜合查詢進階【后】
- 5 小試綜合查詢【后】
- 6 初始化【前】
- 7 M層【前】
- 8 單元測試與分頁【前】
- 9 單選與多選【前】
- 10 集成測試
- 第七節 編輯學生
- 1 初始化【前】
- 2 嵌套組件測試【前】
- 3 功能開發【前】
- 4 JsonPath【后】
- 5 spyOn【后】
- 6 集成測試
- 7 @Input 異步傳值【前】
- 8 值傳遞與引入傳遞
- 9 @PreUpdate【后】
- 10 表單驗證【前】
- 第八節 刪除學生
- 1 CSS選擇器【前】
- 2 confirm【前】
- 3 功能開發與測試【后】
- 4 集成測試
- 5 定制提示框【前】
- 6 引入圖標庫【前】
- 第九節 集成測試
- 第五章 登錄與注銷
- 第一節:普通登錄
- 1 原型【前】
- 2 功能設計【前】
- 3 功能設計【后】
- 4 應用登錄組件【前】
- 5 注銷【前】
- 6 保留登錄狀態【前】
- 第二節:你是誰
- 1 過濾器【后】
- 2 令牌機制【后】
- 3 裝飾器模式【后】
- 4 攔截器【前】
- 5 RxJS操作符【前】
- 6 用戶登錄與注銷【后】
- 7 個人中心【前】
- 8 攔截器【后】
- 9 集成測試
- 10 單例模式
- 第六章 課程管理
- 第一節 新增課程
- 1 初始化【前】
- 2 嵌套組件測試【前】
- 3 async管道【前】
- 4 優雅的測試【前】
- 5 功能開發【前】
- 6 實體監聽器【后】
- 7 @ManyToMany【后】
- 8 集成測試【前】
- 9 異步驗證器【前】
- 10 詳解CORS【前】
- 第二節 課程列表
- 第三節 果斷
- 1 初始化【前】
- 2 分頁組件【前】
- 2 分頁組件【前】
- 3 綜合查詢【前】
- 4 綜合查詢【后】
- 4 綜合查詢【后】
- 第節 班級列表
- 第節 教師列表
- 第節 編輯課程
- TODO返回機制【前】
- 4 彈出框組件【前】
- 5 多路由出口【前】
- 第節 刪除課程
- 第七章 權限管理
- 第一節 AOP
- 總結
- 開發規范
- 備用