使用 Spring JDBC 访问关系型数据

本指南带你了解使用 Spring 访问关系型数据的过程。

你将构建什么

你将构建一个应用，使用 Spring 的 JdbcTemplate 访问关系型数据库中保存的数据。

你需要什么

• 约15分钟。
• 喜欢的文本编辑器或 IDE。
• Java 17 或更新版本。
• Gradle 7.5+ 或 Maven 3.5+。
• 也可以直接把代码导入 IDE：Spring Tool Suite（STS）、IntelliJ IDEA 或 VSCode。相应指南链接见文末。

如何完成本指南

和大多数 Spring 入门指南一样，你可以从零开始完成每一步，也可以跳过已经熟悉的基本设置。两条路径最终都会得到可工作的代码。

从零开始，请进入“从 Spring Initializr 开始”一节。

若要跳过基础步骤：

1. 下载并解压本指南的源码仓库，或者使用 Git 克隆：git clone https://github.com/spring-guides/gs-relational-data-access.git。
2. 用 cd 进入 gs-relational-data-access/initial。
3. 直接进入“创建 Customer 类”一节。

完成后，可以把结果与 gs-relational-data-access/complete 中的代码对照。

从 Spring Initializr 开始

你可以使用原文中的预初始化项目，点击 Generate 下载 ZIP。该项目已按教程示例配置。

若要手动初始化：

1. 打开 https://start.spring.io。它会加入应用所需依赖，完成大多数设置。
2. 选择 Gradle 或 Maven，以及你希望使用的语言。
3. 点击 Dependencies，选择 JDBC API 和 H2 Database。
4. 点击 Generate。
5. 下载生成的 ZIP，它是按所选配置创建的 Web 应用归档。

创建 Customer 类

接下来实现的简单数据访问逻辑，会管理客户的名和姓。为在应用层表示这些数据，创建 Customer 类，如下所示。

Java

package com.example.relationaldataaccess;

public record Customer(long id, String firstName, String lastName) {

	@Override
	public String toString() {
		return String.format(
				"Customer[id=%d, firstName='%s', lastName='%s']",
				id, firstName, lastName);
	}
}

Kotlin

package com.example.relationaldataaccess

data class Customer(
    val id: Long,
    val firstName: String,
    val lastName: String
) {
    override fun toString(): String =
        "Customer[id=$id, firstName='$firstName', lastName='$lastName']"
}

保存和检索数据

Spring 提供名为 JdbcTemplate 的模板类，简化 SQL 关系型数据库和 JDBC 的使用。大量 JDBC 代码陷在资源获取、连接管理、异常处理以及与业务目标无关的一般错误检查中。JdbcTemplate 会处理这些工作，你只需关注当前任务。以下类通过 JDBC 保存和检索数据。

Java

package com.example.relationaldataaccess;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@SpringBootApplication
public class RelationalDataAccessApplication implements CommandLineRunner {

	private static final Logger log = LoggerFactory.getLogger(RelationalDataAccessApplication.class);

	public static void main(String[] args) {
		SpringApplication.run(RelationalDataAccessApplication.class, args);
	}

	private final JdbcTemplate jdbcTemplate;

	public RelationalDataAccessApplication(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	@Override
	public void run(String... strings) throws Exception {

		log.info("Creating tables");

		jdbcTemplate.execute("DROP TABLE IF EXISTS customers");
		jdbcTemplate.execute("CREATE TABLE customers(" +
				"id SERIAL, first_name VARCHAR(255), last_name VARCHAR(255))");

		// Split up the array of whole names into an array of first/last names
		List<Object[]> splitUpNames = Stream.of("John Woo", "Jeff Dean", "Josh Bloch", "Josh Long")
				.map(name -> name.split(" "))
				.collect(Collectors.toList());

		// Use a Java 8 stream to print out each tuple of the list
		splitUpNames.forEach(name -> log.info("Inserting customer record for {} {}", name[0], name[1]));

		// Use JdbcTemplate's batchUpdate operation to bulk load data
		jdbcTemplate.batchUpdate("INSERT INTO customers(first_name, last_name) VALUES (?,?)", splitUpNames);

		log.info("Querying for customer records where first_name = 'Josh':");
		jdbcTemplate.query(
				"SELECT id, first_name, last_name FROM customers WHERE first_name = ?",
				(rs, rowNum) -> new Customer(rs.getLong("id"), rs.getString("first_name"), rs.getString("last_name")), "Josh")
		.forEach(customer -> log.info(customer.toString()));
	}
}

Kotlin

package com.example.relationaldataaccess

import org.slf4j.LoggerFactory
import org.springframework.boot.CommandLineRunner
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.jdbc.core.query

private val log = LoggerFactory.getLogger(RelationalDataAccessApplication::class.java)

@SpringBootApplication
class RelationalDataAccessApplication(
    private val jdbcTemplate: JdbcTemplate) : CommandLineRunner {

    override fun run(vararg args: String) {
        log.info("Creating tables")

        jdbcTemplate.execute("DROP TABLE IF EXISTS customers")
        jdbcTemplate.execute(
            """
            CREATE TABLE customers(
                id SERIAL, 
                first_name VARCHAR(255), 
                last_name VARCHAR(255)
            )
        """.trimIndent())

        // Split up the array of whole names into an array of first/last names
        val splitUpNames = listOf("John Woo", "Jeff Dean", "Josh Bloch", "Josh Long")
            .map { it.split(" ").toTypedArray() }

        // Use Kotlin collection functions to print out each tuple of the list
        splitUpNames.forEach { name ->
            log.info("Inserting customer record for {} {}", name[0], name[1])
        }

        // Use JdbcTemplate's batchUpdate operation to bulk load data
        jdbcTemplate.batchUpdate("INSERT INTO customers(first_name, last_name) VALUES (?,?)", splitUpNames)

        log.info("Querying for customer records where first_name = 'Josh':")
        // Import .query() Kotlin extension that allows varargs before lambda to enable trailing lambda syntax
        jdbcTemplate.query("SELECT id, first_name, last_name FROM customers WHERE first_name = ?", "Josh")
        { rs, _ ->
            Customer(
                rs.getLong("id"),
                rs.getString("first_name"),
                rs.getString("last_name")
            )
        }
            .forEach { customer ->
                log.info(customer.toString())
            }
    }
}

fun main(args: Array<String>) {
    runApplication<RelationalDataAccessApplication>(*args)
}

@SpringBootApplication 是便捷注解，组合了以下功能：

• @Configuration：把类标记为应用上下文中 bean 定义的来源。
• @EnableAutoConfiguration：根据类路径设置、其他 bean 和各项属性设置，告诉 Spring Boot 开始添加 bean。
• @ComponentScan：让 Spring 在 com.example.relationaldataaccess 包中查找其他组件、配置和服务。本例没有这些额外对象。

main() 使用 Spring Boot 的 SpringApplication.run() 启动应用。

Spring Boot 支持 H2，也就是内存关系型数据库引擎，并自动创建连接。由于使用 spring-jdbc，Spring Boot 会自动创建 JdbcTemplate。原文接着说明，@Autowired JdbcTemplate 字段会自动加载该对象，使之可用。

应用类实现 Spring Boot 的 CommandLineRunner，意味着应用上下文加载后会执行 run()。

首先，使用 JdbcTemplate 的 execute 方法执行一些 DDL。

其次，把字符串列表拆成名与姓的组合：Java 使用流，Kotlin 使用集合函数。

然后，用 JdbcTemplate 的 batchUpdate 向新建表加入记录。第一个参数是查询字符串；最后一个参数，也就是 Object 实例数组，保存用来替换查询中 ? 位置的变量。

最后，使用 query 在表中检索满足条件的记录。再次通过 ? 创建查询参数，并在调用时传入实际值。原文说明，最后一个参数是 Java 8 lambda，用于把每个结果行转换为新 Customer 对象。

构建可执行 JAR

可以从命令行通过 Gradle 或 Maven 运行应用，也可以构建包含全部依赖、类和资源的单个可执行 JAR，然后运行它。可执行 JAR 便于在开发生命周期中、不同环境间，把服务作为应用交付、管理版本和部署。

使用 Gradle 时，可运行 ./gradlew bootRun。也可以用 ./gradlew build 构建 JAR，再这样运行：

java -jar build/libs/gs-relational-data-access-0.0.1-SNAPSHOT.jar

使用 Maven 时，可运行 ./mvnw spring-boot:run。也可以用 ./mvnw clean package 构建 JAR，再这样运行：

java -jar target/gs-relational-data-access-0.0.1-SNAPSHOT.jar

原文给出的预期输出如下：

2019-09-26 13:46:58.561  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Creating tables
2019-09-26 13:46:58.564  INFO 47569 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2019-09-26 13:46:58.708  INFO 47569 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
2019-09-26 13:46:58.809  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Inserting customer record for John Woo
2019-09-26 13:46:58.810  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Inserting customer record for Jeff Dean
2019-09-26 13:46:58.810  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Inserting customer record for Josh Bloch
2019-09-26 13:46:58.810  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Inserting customer record for Josh Long
2019-09-26 13:46:58.825  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Querying for customer records where first_name = 'Josh':
2019-09-26 13:46:58.835  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Customer[id=3, firstName='Josh', lastName='Bloch']
2019-09-26 13:46:58.835  INFO 47569 --- [           main] c.e.r.RelationalDataAccessApplication    : Customer[id=4, firstName='Josh', lastName='Long']

总结

恭喜，你已经使用 Spring 开发了一个简单 JDBC 客户端。

另请参阅

以下指南也可能有帮助：

• 使用 JPA 访问数据。
• 使用 MongoDB 访问数据。
• 使用 GemFire 访问数据。
• 使用 Neo4j 访问数据。
• 使用 MySQL 访问数据。
• 使用 Spring Boot 构建应用。

希望编写新指南或为已有指南贡献内容？请查看贡献指南。对应链接完整保留在下方。