使用 Spring 和 JDBC 访问关系数据

本指南将引导您完成使用 Spring 访问关系数据的过程。

您将构建什么

您将构建一个应用程序,该应用程序使用 Spring 的 JdbcTemplate 来访问存储在关系数据库中的数据。

你需要什么

如何完成本指南

与大多数 Spring 入门指南一样,您可以从头开始并完成每个步骤,也可以跳过您已熟悉的基本设置步骤。无论哪种方式,您最终都会得到可工作的代码。

从头开始,请转到从 Spring Initializr 开始

跳过基础知识,请执行以下操作

完成时,您可以对照 gs-relational-data-access/complete 中的代码来检查您的结果。

从 Spring Initializr 开始

您可以使用这个预初始化项目并点击生成以下载 ZIP 文件。该项目已配置为适合本教程中的示例。

手动初始化项目

  1. 导航到 https://start.spring.io。此服务会为您拉取应用程序所需的所有依赖项,并为您完成大部分设置。

  2. 选择 Gradle 或 Maven 以及您想要使用的语言。

  3. 点击 Dependencies 并选择 JDBC APIH2 Database

  4. 单击生成

  5. 下载生成的 ZIP 文件,这是一个已根据您的选择配置好的 Web 应用程序存档。

如果您的 IDE 集成了 Spring Initializr,您可以从 IDE 中完成此过程。
您还可以从 GitHub fork 项目,并在您的 IDE 或其他编辑器中打开它。

创建 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:告诉 Spring Boot 根据类路径设置、其他 Bean 以及各种属性设置开始添加 Bean。

  • @ComponentScan:告诉 Spring 在 com.example.relationaldataaccess 包中查找其他组件、配置和服务。在这种情况下,没有。

main() 方法使用 Spring Boot 的 SpringApplication.run() 方法来启动应用程序。

Spring Boot 支持 H2(一个内存关系数据库引擎)并自动创建连接。由于我们使用了 spring-jdbc,Spring Boot 会自动创建一个 JdbcTemplate@Autowired JdbcTemplate 字段会自动加载它并使其可用。

这个 Application 类实现了 Spring Boot 的 CommandLineRunner,这意味着它将在应用程序上下文加载后执行 run() 方法。

首先,使用 JdbcTemplateexecute 方法安装一些 DDL。

其次,获取一个字符串列表,并使用 Java 中的流或 Kotlin 中的集合函数将其拆分为姓/名对。

然后,使用 JdbcTemplatebatchUpdate 方法在您新创建的表中安装一些记录。方法调用的第一个参数是查询字符串。最后一个参数(Object 实例的数组)保存要在查询中替换 ? 字符的变量。

对于单个插入语句,JdbcTemplateinsert 方法很好。但是,对于多个插入,最好使用 batchUpdate
使用 ? 作为参数以通过指示 JDBC 绑定变量来避免 SQL 注入攻击

最后,使用 query 方法搜索表中与条件匹配的记录。您再次使用 ? 参数来创建查询的参数,在调用时传入实际值。最后一个参数是一个 Java 8 lambda,用于将每一行结果转换为新的 Customer 对象。

Lambda 很好地映射到单个方法接口,例如 Spring 的 RowMapper(Java lambda 或带有接收者的 Kotlin 函数字面量)。

构建可执行 JAR

您可以使用 Gradle 或 Maven 从命令行运行应用程序。您还可以构建一个包含所有必要依赖项、类和资源并运行的单个可执行 JAR 文件。构建可执行 JAR 使在整个开发生命周期中,跨不同环境等,轻松交付、版本化和部署服务作为应用程序。

如果您使用 Gradle,您可以通过使用 ./gradlew bootRun 运行应用程序。或者,您可以通过使用 ./gradlew build 构建 JAR 文件,然后按如下方式运行 JAR 文件

java -jar build/libs/gs-relational-data-access-0.1.0.jar

如果您使用 Maven,您可以通过使用 ./mvnw spring-boot:run 运行应用程序。或者,您可以使用 ./mvnw clean package 构建 JAR 文件,然后按如下方式运行 JAR 文件

java -jar target/gs-relational-data-access-0.1.0.jar
这里描述的步骤创建了一个可运行的 JAR。您还可以构建一个经典的 WAR 文件

您应该看到以下输出:

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 客户端。

Spring Boot 提供了许多用于配置和自定义连接池的功能——例如,连接到外部数据库而不是内存数据库。有关更多详细信息,请参阅参考指南

另请参阅

以下指南也可能有所帮助

想写新指南或为现有指南做贡献吗?请查看我们的贡献指南

所有指南的代码均采用 ASLv2 许可,文字内容采用署名-禁止演绎知识共享许可

获取代码