## Spring JDBC
Spring 框架对 JDBC 进行了简单封装，提供了一个 JDBCTemplate 对象简化 JDBC 的开发过程
### 使用方法
1. 导入相关 jar 包（文章尾部有下载地址）
2. 创建 JdbcTemplate 对象，依赖于数据源 DataSource
```java
JdbcTemplate template = new JdbcTemplate(ds);
```
3. 调用对应的方法来完成 CRUD 的操作
* update()：执行 DML 即增、删、改语句
* queryForMap()：执行 DQL 查询语句，并将结果集封装为 Map 集合，字段名为 key，值作为 value，注意：这个方法查询的结果集长度只能是 1，也就是一条记录
* queryForList()：执行 DQL 查询语句，并将结果集封装为 List 集合，List 中存储的是 Map 对象，一个 Map 对象对应一条记录
* query()：执行 DQL 查询语句，并将结果集封装为 JavaBean 对象，该方法的参数为 RowMapper，一般使用 BeanPropertyRowMapper 实现类，可以完成数据到 JavaBean 的自动封装
```java
new BeanPropertyRowMapper<类型>(类型.class)
```
* queryForObject()：执行 DQL 查询语句，并将结果集封装为对象，一般用于聚合函数的查询
## 应用实例
**需求**：针对 emp 表的增删改查
1. 修改 id 为 1001 的记录的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询 id 为 1001 的记录，将其封装为 Map 集合
5. 查询所有记录，将其封装为 List
6. 查询所有记录，将其封装为 Emp 对象的 List 集合
7. 查询总记录数
Druid 连接池配置文件
```properties
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db3?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username=root
password=root
initialSize=10
maxActive=15
maxWait=3000
validationQuery:SELECT 1
```
实体类
```java
package cool.yzt.domain;
import java.util.Date;
/**
* @Author: yzt
* @Description:实体类
*/
public class Emp {
private Integer id;
private String ename;
private Integer job_id;
private Integer mgr;
private Date joindate;
private Double salary;
private Double bonus;
private Integer dept_id;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public Integer getJob_id() {
return job_id;
}
public void setJob_id(Integer job_id) {
this.job_id = job_id;
}
public Integer getMgr() {
return mgr;
}
public void setMgr(Integer mgr) {
this.mgr = mgr;
}
public Date getJoindate() {
return joindate;
}
public void setJoindate(Date joindate) {
this.joindate = joindate;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Double getBonus() {
return bonus;
}
public void setBonus(Double bonus) {
this.bonus = bonus;
}
public Integer getDept_id() {
return dept_id;
}
public void setDept_id(Integer dept_id) {
this.dept_id = dept_id;
}
@Override
public String toString() {
return "Emp{" +
"id=" + id +
", ename='" + ename + '\'' +
", job_id=" + job_id +
", mgr=" + mgr +
", joindate=" + joindate +
", salary=" + salary +
", bonus=" + bonus +
", dept_id=" + dept_id +
'}';
}
}
```
JDBC 工具类
```java
package cool.yzt.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
* @Author: yzt
* @Description: JDBC 工具类
*/
public class JDBCUtiles {
private static DataSource ds;
static {
try {
Properties pros = new Properties();
pros.load(JDBCUtiles.class.getClassLoader().getResourceAsStream("druid.properties"));
ds = DruidDataSourceFactory.createDataSource(pros);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
public static void close(Statement statement,Connection connection) {
close(null,statement,connection);
}
public static void close(ResultSet rs,Statement statement, Connection connection) {
if(rs!=null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(statement!=null) {
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(connection!=null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static DataSource getDataSource() {
return ds;
}
}
```
测试类，方便起见，使用 JUnit 进行单元测试
```java
package cool.yzt.demo;
import cool.yzt.domain.Emp;
import cool.yzt.utils.JDBCUtiles;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
import java.util.Map;
/**
* @Author: yzt
* @Description: 测试类
*/
public class JdbcTemplateDemo1 {
// 获取一个JdbcTemplate对象，方便统一测试，入参为数据库连接池对象，从JDBC工具类获取
private static JdbcTemplate template = new JdbcTemplate(JDBCUtiles.getDataSource());
@Test
public void test1() {
// 将id为1001的记录的salary字段设置为10000，使用?作为参数的占位符，防止sql注入问题
String sql = "update emp set salary = ? where id = ?";
// 入参分别为sql语句，参数（按顺序）
template.update(sql,10000,1001);
}
@Test
public void test2() {
// 添加一条记录
String sql = "insert into emp (id,ename,dept_id) values (?,?,?)";
template.update(sql,1015,"郭靖",10);
}
@Test
public void test3() {
// 删除一条记录
String sql = "delete from emp where id = ?";
template.update(sql,1015);
}
@Test
public void test4() {
String sql = "select * from emp where id = ?";
// 结果集中只有一条记录，封装为Map对象，泛型为
Map map = template.queryForMap(sql,1001);
System.out.println(map);
// 打印结果
// {id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
}
@Test
public void test5() {
String sql = "select * from emp";
// 将结果集中的每一条记录封装为Map对象在装载进List中
List> list = template.queryForList(sql);
for(Map map : list) {
System.out.println(map);
}
}
@Test
public void test6() {
String sql = "select * from emp";
// 入参为sql、BeanPropertyRowMapper对象（泛型和入参要指明JavaBean的类型和class对象）、其他?参数
List list = template.query(sql,new BeanPropertyRowMapper(Emp.class));
for(Emp emp : list) {
System.out.println(emp);
}
}
@Test
public void test7() {
String sql = "select count(id) from emp";
// 结果集封装为一个对象，入参要指明对象的class
Integer num = template.queryForObject(sql,Integer.class);
System.out.println(num);
}
}
```
## 参考
* [黑马 JavaWeb](https://www.bilibili.com/video/BV1J4411877m)
* [数据库复习笔记](https://blog.csdn.net/m0_37989980/article/details/103987924)
**使用的 jar 包**
* [Spring JDBCTemplate 必要 jar 包](https://pan.yzt.cool/Software/%E5%B8%B8%E7%94%A8jar%E5%8C%85/Spring-JDBCTemplate/)
MySQL | Spring JDBCTemplate
