devbox
编程领航者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot 访问数据库——JdbcTemplate

作者：编程领航者 | 2024-01-29 23:01:16

赞

踩

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

  • 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;	
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

  • DataSource 在Applicaton 配置文件中以 spring.datasource.* 作为配置项。

    spring:
	datasource:
		url: jdbc:mysql://localhost:3306/自己的数据库名
		username: root（自己的用户名，一般都是root）
		password: 登录数据库的密码

    • 1
    • 2
    • 3
    • 4
    • 5

  • 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;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    # 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');

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
  • 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方法
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
public class ArticleDetail {
    private Integer id;
    private Integer articleId;
    private String content;
    //全参构造、无参构造、toString、set和get方法
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

四、轻量的 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;
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 项目中依赖了 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);
    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

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));
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

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);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

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);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

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);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

五、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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

六、多表查询

  • 多表查询关注的是查询结果如何映射为 Java Object。常用两种方案：
    • 第一种是将查询结果转化为Map。key是列名，value是列值，这种方式比较通用，适合查询任何表。
    @SpringBootTest
class JdbcTemplateApplicationTests {
    @Autowired
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    @Test
    void testNameQuery(){
        String sql = "select a.*, d.content from article a join article_detail d on a.id = d.article_id where a.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);
        });
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 第二种是根据查询结果中包含的列，创建相应的实体类。属性和查询结果的列对应。
    	@SpringBootTest
class JdbcTemplateApplicationTests {
    @Autowired
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    @Test
    void testNameQuery(){
        String sql = "select a.*, d.content from article a join article_detail d on a.id = d.article_id where a.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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/45542
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号