## 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

MySQL | Spring JDBCTemplate