目录
Δ前言
- 第六节内容，up主要和大家分享一下Spring JdbcTemplate相关的内容；包括JdbcTemplage的基本介绍，基本使用和进阶使用。
- 注意事项——①代码中的注释也很重要；②不要眼高手低，自己跟着敲一遍才真正有收获；③点击文章的侧边栏目录或者文章开头的目录可以进行跳转。
- 良工不示人以朴，up所有文章都会适时补充完善。大家如果有问题都可以在评论区进行交流或者私信up。感谢阅读！
一、什么是JdbcTemplate？
1.定义：
JdbcTemplate 是 Spring 框架提供的一个核心 JDBC 工具类，位于 org.springframework.jdbc.core 包中。它简化了 JDBC 数据库操作，避免了繁琐的 JDBC 代码编写，提高了开发效率。
2.作用：
- 执行 SQL 语句：JdbcTemplate 提供了多种方法来执行 SQL 语句，包括查询、更新、插入、删除等。
- 处理结果集：JdbcTemplate 可以自动将查询结果转换为 Java 对象，简化了结果集的处理。
- 管理数据库连接：JdbcTemplate 自动管理数据库连接的获取和释放，避免了资源泄漏。
- 处理异常：JdbcTemplate 将 JDBC 异常转换为 Spring 的统一数据访问异常，方便进行异常处理。
- 支持事务：JdbcTemplate 可以与 Spring 的事务管理机制集成，实现事务控制。
3.环境搭建：
首先，我们需要在原来项目的基础上，增加如下五个jar包（up此处选用Druid连接池作为演示，大家亦可用其他连接池）——
并把它们加入到项目中。
接着，我们要选择一个用于测试的数据库，此处up为了演示，新建一个"spring_test" 数据库，代码如下：
CREATE DATABASE spring_test;
USE spring_test;
CREATE TABLE IF NOT EXISTS `blog_column` (
`id` INT NOT NULL UNIQUE,
`bc_name` VARChAR(128)
) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin ENGINE INNODB;
INSERT INTO `blog_column`
VALUES
(1, 'java基础'),
(2, 'java进阶'),
(3, 'java高级'),
(4, 'javaWEB'),
(5, 'java内功'),
(6, 'java框架'),
(7, 'DB'),
(8, 'Technology_Stack'),
(9, 'C');
SELECT * FROM `blog_column`;然后，需要配置properties文件（创建在src目录下），up配置的druid.properties配置文件，代码如下：
# 选择驱动
driverClassName=com.mysql.cj.jdbc.Driver
# 选择数据库
url=jdbc:mysql://localhost:3306/spring_test?rewriteBatchedStatements=true&characterEncoding=UTF-8
# 配置用户名
jdbc.username=root
# 配置用户密码
jdbc.password=RA9_Cyan
# 初始化连接数量
initialSize=10
# 最小连接数量
minIdle = 5
# 最大连接数量
maxActive=50
# 超时时间5000ms（在等待队列中的最长等待时间，若超过，放弃此次请求）
maxWait=5000
接着，还是在src目录下，配置xml文件，up以 beans_jdbcTemplate.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:contex="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 配置properties文件 -->
<contex:property-placeholder location="classpath:druid.properties"/>
<!-- 配置数据源对象 -->
<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource01">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 配置JdbcTemplate对象 -->
<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate01">
<property name="dataSource" ref="dataSource01"/>
</bean>
</beans>那么配置好之后就可以测试了，JdbcTemplateTest测试类代码如下：
package com.cyan.spring.test;
import com.alibaba.druid.pool.DruidDataSource;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
* @author : Cyan_RA9
* @version : 22.0
*/
public class JdbcTemplateTest {
@Test
public void testJdbcTemplate() throws SQLException {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
//通过接口来获取数据源对象
DataSource dataSource = ioc.getBean("dataSource01", DataSource.class);
Connection connection = dataSource.getConnection();
System.out.println("dataSource's class = " + dataSource.getConnection());
System.out.println("connection = " + connection);
connection.close();
}
}
运行结果：
并且，如果我们在Debug下检查IOC容器，会发现singletonObjects单例池中，成功被注入了DataSource对象，如下图所示：
二、JdbcTemplate的简单使用
1.通过JdbcTemplate实现数据的添加：
需求：向表中新增两条记录，用两种方法实现。
就在刚在的JdbcTemplateTest测试类下，我们用配置的JdbcTemplate对象实现数据添加，代码如下：
@Test
public void testJdbcTemplate() throws SQLException {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
//通过接口来获取数据源对象
DataSource dataSource = ioc.getBean("dataSource01", DataSource.class);
Connection connection = dataSource.getConnection();
System.out.println("dataSource's class = " + dataSource.getConnection());
System.out.println("connection = " + connection);
JdbcTemplate jdbcTemplate = ioc.getBean("jdbcTemplate01", JdbcTemplate.class);
String sql1 = "INSERT INTO `blog_column` VALUES (10, 'Java刷题');";
String sql2 = "INSERT INTO `blog_column` VALUES (?, ?);";
//添加方式一 ：通过execute方法添加
jdbcTemplate.execute(sql1);
//添加方式二 ：通过update方法添加
int affectedRows = jdbcTemplate.update(sql2, 11, "Java书籍");
System.out.println("affectedRows = " + affectedRows);
connection.close();
}运行结果：
检查数据库中的 blog_column 表，发现记录添加成功，如下所示：
2.通过JdbcTemplate实现数据的修改：
需求：将 blog_column 表中的 3---java高级 记录，改为 3---Java_Advanced。
仍然是在JdbcTemplateTest类，新增一个单元测试方法，代码如下：
@Test
public void testUpdateByJdbcTemplate() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
JdbcTemplate jdbcTemplate = ioc.getBean("jdbcTemplate01", JdbcTemplate.class);
String sql = "UPDATE `blog_column` SET bc_name = ? WHERE `id` = ?;";
int affectedRows = jdbcTemplate.update(sql, "Java_Advanced", 3);
System.out.println("affectedRows = " + affectedRows);
}运行结果：
同时，我们查看数据库中的 blog_column 表，会发现 id = 3 的记录已经被成功修改，如下图所示：
三、JdbcTemplate的进阶使用
1.数据批量处理：
需求：通过批处理机制，连续向 blog_column 表中插入三条记录。
在JdbcTemplateTest类下新增一个用于单元测试的方法，代码如下：
@Test
public void testBatchProcessByJdbcTemplate() throws SQLException {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
String sql = "INSERT INTO `blog_column` VALUES (?, ?);";
List<Object[]> parametersList = new ArrayList<>();
parametersList.add(new Object[] { 12, "待定1"});
parametersList.add(new Object[] { 13, "待定2"});
parametersList.add(new Object[] { 14, "待定3"});
jdbcTemplate.batchUpdate(sql, parametersList);
}运行后，我们可以看到 spring_test 数据库中的 blog_column 表中，又加入了三条新的数据，如下所示：
2.查询到的数据封装到Bean对象：
需求：查询 blog_column 表中 id = 5的专栏，并将查到的记录以 Column对象 的形式封装起来。
首先我们来建立一个 标准JavaBean 的Column类，代码如下：
package com.cyan.spring.bean;
/**
* @author : Cyan_RA9
* @version : 22.0
*/
public class Column {
private int columnId;
private String columnName;
public Column() {
}
public Column(int columnId, String columnName) {
this.columnId = columnId;
this.columnName = columnName;
}
public int getColumnId() {
return columnId;
}
public void setColumnId(int columnId) {
this.columnId = columnId;
}
public String getColumnName() {
return columnName;
}
public void setColumnName(String columnName) {
this.columnName = columnName;
}
@Override
public String toString() {
return "Column{" +
"columnId=" + columnId +
", columnName='" + columnName + '\'' +
'}';
}
}
然后，我们在JdbcTemplateTest测试类中，继续新增一个单元测试方式，代码如下：
@Test
public void testEncapsulateToObjectByJdbcTemplate() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
JdbcTemplate jdbcTemplate = (JdbcTemplate) ioc.getBean("jdbcTemplate01");
String sql = "SELECT `id` AS `columnId`, bc_name AS `columnName` " + "\n" +
"FROM `blog_column`" + "\n" +
"WHERE `id` = ?;";
//多态，注意参数列表传入了目标Bean的字节码文件对象
RowMapper<Column> rowMapper = new BeanPropertyRowMapper<>(Column.class);
Column column = jdbcTemplate.queryForObject(sql, rowMapper, 5);
System.out.println("column = " + column);
}运行结果 :
3.查询到的数据以Bean对象的形式封装到集合中：
需求：查询 blog_column 表中 id <= 6的专栏，并将查到的记录以 List集合 的形式封装起来。
在JdbcTemplateTest测试类中，继续新增一个单元测试方式，代码如下：
@Test
public void testEncapsulateToListByJdbcTemplate() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
JdbcTemplate jdbcTemplate = (JdbcTemplate) ioc.getBean("jdbcTemplate01");
String sql = "SELECT `id` AS `columnId`, bc_name AS `columnName` " + "\n" +
"FROM `blog_column`" + "\n" +
"WHERE `id` <= ?;";
RowMapper<Column> rowMapper = new BeanPropertyRowMapper<>(Column.class);
List<Column> columnList = jdbcTemplate.query(sql, rowMapper, 6);
for (Column column : columnList) {
System.out.println("column = " + column);
}
}运行结果：
4.查询单行单列的具体字段：
需求：查询 blog_column 表中 id = 8 的专栏名称（即返回该专栏的bc_name）。
在JdbcTemplateTest测试类中，继续新增一个单元测试方式，代码如下：
@Test
public void testQueryOneSpecificFieldByJdbcTemplate() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
JdbcTemplate jdbcTemplate = (JdbcTemplate) ioc.getBean("jdbcTemplate01");
String sql = "SELECT `bc_name` FROM `blog_column` WHERE `id` = ?;";
String bc_name = jdbcTemplate.queryForObject(sql, String.class, 8);
System.out.println("bc_name = " + bc_name);
}运行结果：
5.使用具名参数添加数据：
以往我们使用SQL语句时，总是用到占位符 ? ，就像我们上面刚刚用到的SQL语句，如下图所示：
这么做有个问题——除非我们知道对应表的结构，不然就无法确定这个占位符? 应该传入什么参数。
使用具名参数可以很好的解决这个问题。
需求：以具名参数的形式向 blog_column表中新插入两条记录。
首先在之前的 beans_jdbcTemplate.xml 配置文件下新配置一个 NamedParameterJdbcTemplate 对象，如下：
<!-- 配置NamedParameterJdbcTemplate -->
<bean class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate" id="namedParameterJdbcTemplate">
<constructor-arg name="dataSource" ref="dataSource01"/>
</bean>仍然在JdbcTemplateTest类中，新增一个单元测试方法，
@Test
public void testNamedParameterJdbcTemplate() {
//获取Spring 容器对象
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_jdbcTemplate.xml");
//通过 id和类型 获取容器中的 NamedParameterJdbcTemplate实例
NamedParameterJdbcTemplate namedParameterJdbcTemplate = ioc.getBean("namedParameterJdbcTemplate", NamedParameterJdbcTemplate.class);
//1. 方式一: int update(String var1, Map<String, ?> var2)
String sql1 = "INSERT INTO `blog_column` VALUES(:id, :name);";
Map<String, Object> parameterMap = new HashMap<>();
parameterMap.put("id", 15);
parameterMap.put("name", "待定4");
namedParameterJdbcTemplate.update(sql1, parameterMap);
//2. 方式二：使用 SqlParameterSource 来封装具名参数
//int update(String var1, SqlParameterSource var2)
//注意此时具名参数的名称必须与JavaBean一致
String sql2 = "INSERT INTO `blog_column` VALUES(:columnId, :columnName);";
//接口多态
Column columnTest = new Column(16, "待定5");
SqlParameterSource sqlParameterSource = new BeanPropertySqlParameterSource(columnTest);
namedParameterJdbcTemplate.update(sql2, sqlParameterSource);
}运行结果如下：
Δ总结
- 🆗，以上就是Spring系列博文 第六小节 的全部内容了。
- 总结一下，JdbcTemplate相比于之前的 IOC，AOP，要好理解很多，因为它就是Spring提供的 操作数据库 的技术嘛；所以对于JdbcTemplate，其实更重要的是我们能不能熟练地使用它，做到熟能生巧的地步。
- 下一节内容，也是Spring系列的最后一节内容——Spring 声明式事务，大家不见不散，感谢阅读！
System.out.println("END---------------------------------------------");