Spring Boot 访问数据库——JdbcTemplate
① Spring Boot 框架为 SQL 数据库提供了广泛的支持，既有用 JdbcTemplate 直接访问 JDBC，同时支持“object relational mapping”技术（如 Hibernate、MyBatis）。Spring Data 独立的项目提供对多种关系型和非关系型数据库的访问支持。比如 MySQL、Oracle、MongDB、Redis、R2DBC、Apache Solr、Elasticsearch…
② Spring Boot 也支持嵌入式数据库比如 H2，HSQL，Derby。这些数据库只需要提供 jar 包就能在内存中维护数据。
③ 本篇博客主要讲解如何使用 Spring Boot 中的 JdbcTemplate 访问关系型数据库。
JdbcTemplate
- 一、配置数据源 DataSource
- 二、准备数据库环境
- 三、准备实体类
- 四、轻量的 JdbcTemplate
-
- 1.单条DML语句测试-update方法
- 2.批量DML语句测试-batchUpdate方法
- 3.查询一个对象和查询一个值
- 4.查询多个对象
- 5.自定义RowMapper
- 五、NameParameterJdbcTemplate
- 六、多表查询
一、配置数据源 DataSource
-
DataSourceProperties.java 是数据源的配置类，有那些可以配置的可以参看源码。
@ConfigurationProperties(prefix = "spring.datasource") public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean { private ClassLoader classLoader; private boolean generateUniqueName = true; private String name; private Class<? extends DataSource> type; private String driverClassName; private String url; private String username; private String password; private String jndiName; private EmbeddedDatabaseConnection embeddedDatabaseConnection; private Xa xa = new Xa(); private String uniqueName; } -
DataSource 在Applicaton 配置文件中以 spring.datasource.* 作为配置项。
spring: datasource: url: jdbc:mysql://localhost:3306/自己的数据库名 username: root（自己的用户名，一般都是root） password: 登录数据库的密码 -
Spring Boot 能够从 spring.datasource.url 推断所使用的数据驱动类，如果需要特殊指定请设置 spring.datasource.driverClassName 为驱动类的全限定名称。
-
Spring Boot 支持多种数据库连接池，优先使用 HikariCP，其次是 Tomcat pooling，再次是 Commons DBCP2，如果以上都没有，最后使用 Oracle UCP 连接池。当项目中 starter 依赖了 spring-boot-starter-jdbc 或者 spring-boot-stater-data-jpa 默认添加 HikariCP 连接池依赖，也就是默认使用 HikariCP 连接池。
二、准备数据库环境
- 访问数据库先准备数据库的 script。SpringBoot 能够自动执行 DDL，DML 脚本。两个脚本文件名称默认是 schema.sql 和 data.sql。脚本文件在类路径中自动加载。
- 自动执行脚本使用配置项 spring.sql.inti.mode 配置项
- always 表示Spring Boot应用启动时始终执行数据库初始化
- embedded 表示只初始化内存数据库，比如 H2 数据库
- never 表示从不执行初始化数据库
# schema.sql 文件 DROP TABLE IF EXISTS `article`; CREATE TABLE `article` ( `id` int NOT NULL AUTO_INCREMENT COMMENT '主键', `user_id` int NOT NULL COMMENT '作者 ID', `title` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '文章标题', `summary` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '文章概要', `read_count` int(11) UNSIGNED ZEROFILL NOT NULL COMMENT '阅读读数', `create_time` datetime NOT NULL COMMENT '创建时间', `update_time` datetime NOT NULL COMMENT '最后修改时间', PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = UTF8MB4_0900_AI_CI ROW_FORMAT = Dynamic; DROP TABLE IF EXISTS `article_detail`; CREATE TABLE `article_detail` ( `id` int NOT NULL AUTO_INCREMENT COMMENT '注解', `article_id` int NOT NULL COMMENT '文章 ID', `content` text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '文章内容', PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;# data.sql 文件 -- ---------------------------- -- Records of article -- ---------------------------- INSERT INTO `article` VALUES (1, 2101, 'SpringBoot 核心注解', '核心注解的主要作用', 00000008976, '2023-01-16 12:11:12', '2023-01-16 12:11:19'); INSERT INTO `article` VALUES (2, 356752, 'JVM 调优', 'HotSpot 虚拟机详解', 00000000026, '2023-01-16 12:15:27', '2023-01-16 12:15:30'); -- ---------------------------- -- Records of article_detail -- ---------------------------- INSERT INTO `article_detail` VALUES (1, 1, '注解十分的重要，例如：SpringBootApplication'); - Spring Boot 处理特定的数据库类型，为特定的数据库定制 script 文件。首先设置 spring.sql.init.platform = hsqdb、h2、Oracle、postgresql 等等，其次准备 schema-${platform}.sql、data-${platform}.sql 脚本文件。
三、准备实体类
public class ArticleDetail {
private Integer id;
private Integer userId;
private String summary;
private String title;
private Integer readCount;
private LocalDateTime createTime;
private LocalDateTime updateTime;
//全参构造、无参构造、toString、set和get方法
}
public class ArticleDetail {
private Integer id;
private Integer articleId;
private String content;
//全参构造、无参构造、toString、set和get方法
}
四、轻量的 JdbcTemplate
//Jdbc绑定Bean的源码
@ConfigurationProperties(prefix = "spring.jdbc")
public class JdbcProperties {
private final Template template = new Template();
public Template getTemplate() {
return this.template;
}
public static class Template {
/**
* Number of rows that should be fetched from the database when more rows are
* needed. Use -1 to use the JDBC driver's default configuration.
*/
private int fetchSize = -1;
/**
* Maximum number of rows. Use -1 to use the JDBC driver's default configuration.
*/
private int maxRows = -1;
/**
* Query timeout. Default is to use the JDBC driver's default configuration. If a
* duration suffix is not specified, seconds will be used.
*/
@DurationUnit(ChronoUnit.SECONDS)
private Duration queryTimeout;
}
}
- 项目中依赖了 spring-jdbc，JdbcTemplate 对象会自动创建好。把 JdbcTemplate 对象注入给你的 Bean，再调用 JdbcTemplate 的方法执行查询，更新，删除的SQL。
- JdbcTemplate 上手快，功能非常强大。提供了丰富、实用的方法，归纳起来主要有以下几种类型的方法：
- execute 方法：可以用于执行任何的 SQL 语句，常用来执行 DDL 语句。
- upate、batchUpdate 方法：用于 DML 语句。
- query 和 queryForXXX 方法：用于执行 DQL 语句。
- call 方法：用于执行数据库存储过程和函数相关语句。
1.单条DML语句测试-update方法
- update方法有两个参数：
- 第一个参数：要执行的SQL语句。（SQL语句中可能会有占位符 ? ）
- 第二个参数：可变长参数，参数的个数可以是0个，也可以是多个。一般是SQL语句中有几个问号，则对应几个参数。
@SpringBootTest
class JdbcTemplateApplicationTests {
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
void insert() {
String sql = "insert into article_detail (article_id, content) values (?, ?)";
int count = jdbcTemplate.update(sql, 2, "JVM 十分的重要，一定要去学习。");
System.out.println("插入的记录条数是：" + count);
}
@Test
void modify() {
String sql = "update article_detail set content = ? where id = ?";
int count = jdbcTemplate.update(sql, "Spring Boot 中的核心注解十分重要", 2);
System.out.println("修改的记录条数是：" + count);
}
@Test
void delete() {
String sql = "delete from article_detail where id = ?";
int count = jdbcTemplate.update(sql, 2);
System.out.println("删除的记录条数是：" + count);
}
}
2.批量DML语句测试-batchUpdate方法
@SpringBootTest
class JdbcTemplateApplicationTests {
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
void batchInsert() {
String sql = "insert into article_detail (article_id, content) values (?, ?)";
Object[] obj1 = {2, "JVM 十分的重要，一定要去学习。"};
Object[] obj2 = {1, "SpringBoot 十分的重要，一定要去学习。"};
Object[] obj3 = {2, "JVM 学习了之后一定会大有收获的"};
List<Object[]> list = new ArrayList<>();
list.add(obj1);
list.add(obj2);
list.add(obj3);
int[] count = jdbcTemplate.batchUpdate(sql, list);
System.out.println("插入的记录条数是：" + Arrays.toString(count));
}
@Test
void batchModify() {
String sql = "update article_detail set content = ? where id = ?";
Object[] obj1 = {"测试更新", 4};
Object[] obj2 = {"测试更新", 5};
Object[] obj3 = {"测试更新", 3};
List<Object[]> list = new ArrayList<>();
list.add(obj1);
list.add(obj2);
list.add(obj3);
int[] count = jdbcTemplate.batchUpdate(sql, list);
System.out.println("更新的记录条数是：" + Arrays.toString(count));
}
@Test
void batchDelete() {
String sql = "delete from article_detail where id = ?";
Object[] obj1 = {4};
Object[] obj2 = {5};
Object[] obj3 = {3};
List<Object[]> list = new ArrayList<>();
list.add(obj1);
list.add(obj2);
list.add(obj3);
int[] count = jdbcTemplate.batchUpdate(sql, list);
System.out.println("删除的记录条数是：" + Arrays.toString(count));
}
}
3.查询一个对象和查询一个值
- queryForObject方法三个参数：
- 第一个参数：sql语句
- 第二个参数：Bean属性值和数据库记录行的映射对象。在构造方法中指定映射的对象类型。
- 第三个参数：可变长参数，给sql语句的占位符问号传值。
- 这个方法查询出来的结果只能是一个数据，如果多于一个数据或者没有查询到数据就会报错。
@SpringBootTest
class JdbcTemplateApplicationTests {
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
void queryOneObject(){
String sql = "select * from article where id = ?";
Article article = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Article.class), 1);
System.out.println(article);
}
@Test
void queryOneOValue(){
String sql = "select count(*) from article";
Long count = jdbcTemplate.queryForObject(sql, Long.class);
System.out.println("查询到的记录条数 =====> " + count);
}
}
4.查询多个对象
@SpringBootTest
class JdbcTemplateApplicationTests {
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
void queryMulObject(){
String sql = "select * from article";
List<Article> articles = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Article.class));
System.out.println(articles);
}
}
5.自定义RowMapper
@SpringBootTest
class JdbcTemplateApplicationTests {
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
void testQueryRowMapper() {
String sql = "select * from article where id = 1";
Article article = jdbcTemplate.execute(sql, new PreparedStatementCallback<Article>() {
@Override
public Article doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
Article article = null;
ResultSet rs = ps.executeQuery();
if (rs.next()) {
var id = rs.getInt("id");
var userId = rs.getInt("user_id");
var title = rs.getString("title");
var summary = rs.getString("summary");
var readCount = rs.getInt("read_count");
var createTime = new Timestamp(rs.getTimestamp("create_time").getTime()).toLocalDateTime();
var updateTime = new Timestamp(rs.getTimestamp("update_time").getTime()).toLocalDateTime();
article = new Article(id, userId, summary, title, readCount, createTime, updateTime);
}
return article;
}
});
System.out.println(article);
}
}
五、NameParameterJdbcTemplate
-
NameParameterJdbcTemplate 能够接受命名的参数，通过具名的参数提供代码的可读性。NameParameterJdbcTemplate 使用的是参数索引的方式。
-
在使用模板的位置上注入 NameParameterJdbcTemplate 对象，编写 SQL 语句，在 SQL 中Where 部分“:命名参数”。调用 NameParameterJdbcTemplate 的诸如 query，queryForObject，execute，update等时，将参数封装到 Map 中。
@SpringBootTest class JdbcTemplateApplicationTests { @Autowired private NamedParameterJdbcTemplate namedParameterJdbcTemplate; @Test void testNameQuery(){ String sql = "select count(*) as ct from article where user_id = :uid and read_count > :num"; Map<String, Object> map = new HashMap<>(); map.put("uid", 2101); map.put("num", 0); Long count = namedParameterJdbcTemplate.queryForObject(sql, map, Long.class); System.out.println(count); } }
六、多表查询
- 多表查询关注的是查询结果如何映射为 Java Object。常用两种方案：
- 第一种是将查询结果转化为Map。key是列名，value是列值，这种方式比较通用，适合查询任何表。
@SpringBootTest class JdbcTemplateApplicationTests { @Autowired private NamedParameterJdbcTemplate namedParameterJdbcTemplate; @Test void testNameQuery(){ String sql = "select a.*, d.article_id, d.content from article a join article_detail d on a.id = d.article_id where d.id = :id"; Map<String, Object> param = new HashMap<>(); param.put("id", 1); Map<String, Object> objectMap = namedParameterJdbcTemplate.queryForMap(sql, param); objectMap.forEach(( key, value)->{ System.out.println(key + "---->" + value); }); } }- 第二种是根据查询结果中包含的列，创建相应的实体类。属性和查询结果的列对应。
@SpringBootTest class JdbcTemplateApplicationTests { @Autowired private NamedParameterJdbcTemplate namedParameterJdbcTemplate; @Test void testNameQuery(){ String sql = "select a.*, d.article_id, d.content from article a join article_detail d on a.id = d.article_id where d.id = :id"; Map<String, Object> param = new HashMap<>(); param.put("id", 1); ArticleAndDetail articleAndDetail = namedParameterJdbcTemplate.queryForObject(sql, param, new BeanPropertyRowMapper<>(ArticleAndDetail.class)); System.out.println(articleAndDetail); } }