[Spring官方教程] - 用Spring-Jdbc访问关系型数据

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

你将建立什么

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

你需要什么

从Spring Initializr开始

对于所有的Spring应用程序,你应该从Spring Initializr开始。Initializr提供了一种快速的方法来获取应用程序所需的所有依赖项,并为你做大量的设置。这个例子需要JDBC API和H2数据库的依赖。

如果你使用Maven,请访问Spring Initializr来生成一个带有所需依赖项(JDBC API和H2数据库)的新项目。

下面的列表显示了选择Maven时创建的pom.xml文件。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.5.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>relational-data-access-initial</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>relational-data-access-initial</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>

		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

如果你使用Gradle,请访问Spring Initializr来生成一个带有所需依赖项(JDBC API和H2数据库)的新项目。

下面的列表显示了当你选择Gradle时创建的build.gradle文件。

plugins {
	id 'org.springframework.boot' version '2.5.2'
	id 'io.spring.dependency-management' version '1.0.11.RELEASE'
	id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-jdbc'
	runtimeOnly 'com.h2database:h2'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
	useJUnitPlatform()
}

手动初始化(可选)

If you want to initialize the project manually rather than use the links shown earlier, follow the steps given below:

  1. 导航到https://start.spring.io。这项服务拉入你的应用程序所需的所有依赖性,并为你做大部分的设置。
  2. 选择Gradle或Maven以及你想使用的语言。本指南假设你选择了Java。
  3. 点击Dependencies,选择JDBC APIH2 Database
  4. 点击Generate
  5. 下载产生的ZIP文件,这是一个用你的选择配置的Web应用程序的档案。

如果你的IDE有Spring Initializr集成,你可以从你的IDE完成这个过程。

创建一个 Customer 对象

你要处理的简单数据访问逻辑是管理客户的名字和姓氏。为了在应用程序层面表示这些数据,创建一个 Customer 类,正如下面的列表(来自src/main/java/com/example/relationaldataaccess/Customer.java)所示。

package com.example.relationaldataaccess;

public class Customer {
  private long id;
  private String firstName, lastName;

  public Customer(long id, String firstName, String lastName) {
    this.id = id;
    this.firstName = firstName;
    this.lastName = lastName;
  }

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

  // getters & setters omitted for brevity
}

存储和检索数据

Spring提供了一个名为 JdbcTemplate 的模板类,使其能够轻松地处理SQL关系数据库和JDBC。大多数JDBC代码都陷入了资源获取、连接管理、异常处理和一般的错误检查中,而这些与代码要实现的目标完全无关。JdbcTemplate 为你解决了所有的问题。你所要做的就是专注于手头的工作。下面的列表(来自src/main/java/com/example/relationaldataaccess/RelationalDataAccessApplication.java)显示了一个可以通过JDBC存储和检索数据的类。

package com.example.relationaldataaccess;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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.Arrays;
import java.util.List;
import java.util.stream.Collectors;

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

  @Autowired
  JdbcTemplate jdbcTemplate;

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

    log.info("Creating tables");

    jdbcTemplate.execute("DROP TABLE customers IF EXISTS");
    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 = Arrays.asList("John Woo", "Jeff Dean", "Josh Bloch", "Josh Long").stream()
        .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(String.format("Inserting customer record for %s %s", name[0], name[1])));

    // Uses 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 = ?", new Object[] { "Josh" },
        (rs, rowNum) -> new Customer(rs.getLong("id"), rs.getString("first_name"), rs.getString("last_name"))
    ).forEach(customer -> log.info(customer.toString()));
  }
}

@SpringBootApplication是一个方便的注解,添加了以下所有内容。

  • @Configuration : 将该类标记为应用程序上下文的Bean定义的来源。
  • @EnableAutoConfiguration : 告诉Spring Boot根据classpath设置、其他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 8流,在一个Java数组中把它们分成名字/姓氏对。

然后通过使用JdbcTemplatebatchUpdate方法在新创建的表中安装一些记录。该方法调用的第一个参数是查询字符串。最后一个参数(“Object” 实例数组)是要被替换到查询中的"? "字符所在的变量。

对于单个插入语句,JdbcTemplateinsert方法很好。但是,对于多次插入,最好使用batchUpdate

使用?作为参数,以避免SQL注入攻击通过指示JDBC来绑定变量。

最后,使用query方法来搜索你的表,寻找符合标准的记录。你再次使用?参数来创建查询的参数,在你调用时传入实际的值。最后一个参数是一个Java 8 lambda,用于将每个结果行转换成一个新的Customer对象。

Java 8的lambdas可以很好地映射到单个方法接口上,比如Spring的`RowMapper’。如果你使用Java 7或更早的版本,你可以插入一个匿名的接口实现,让方法体与lambda表达式的主体相同。

构建一个可执行的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开发了一个简单的JDBC客户端。

Spring Boot有许多配置和定制连接池的功能–例如,连接到外部数据库而不是内存数据库。更多细节请参见参考指南

另见

以下指南也可能有所帮助。

想写一个新的指南或对现有的指南做出贡献?请查看我们的贡献指南


原文:Getting Started | Accessing Relational Data using JDBC with Spring