SpringBoot 2 使用 R2DBC 来并发访问关系型数据库

开篇词

该指南将引导你构建使用 Spring Data R2DBC 反应式数据库驱动在关系数据库中存储和检索数据的应用。
 

你将创建的应用

我们将构建一个应用，该应用将 Customer POJO（经典的 Java 对象）存储在基于内存的数据库中。
 

你将需要的工具

• 大概 15 分钟左右；
• 你最喜欢的文本编辑器或集成开发环境（IDE）
• JDK 1.8 或更高版本；
• Gradle 4+ 或 Maven 3.2+
• 你还可以将代码直接导入到 IDE 中：
  • Spring Too Suite (STS)
  • IntelliJ IDEA
     

如何完成这个指南

像大多数的 Spring 入门指南一样，你可以从头开始并完成每个步骤，也可以绕过你已经熟悉的基本设置步骤。如论哪种方式，你最终都有可以工作的代码。

• 要从头开始，移步至从 Spring Initializr 开始；
• 要跳过基础，执行以下操作：
  • 下载并解压缩该指南将用到的源代码，或借助 Git 来对其进行克隆操作：git clone https://github.com/spring-guides/gs-accessing-data-r2dbc.git
  • 切换至 gs-accessing-data-r2dbc/initial 目录；
  • 跳转至该指南的定义模式。

待一切就绪后，可以检查一下 gs-accessing-data-r2dbc/complete 目录中的代码。
 

从 Spring Initializr 开始

对于所有的 Spring 应用来说，你应该从 Spring Initializr 开始。Initializr 提供了一种快速的方法来提取应用程序所需的依赖，并为你完成许多设置。该示例需要 R2DBC 和 H2 依赖。下图显示了此示例项目的 Initializr 设置：

上图显示了选择 Maven 作为构建工具的 Initializr。你也可以使用 Gradle。它还将 com.example 和 accesing-data-r2dbc 的值分别显示为 Group 和 Artifact。在本示例的其余部分，将用到这些值。

以下清单显示了选择 Maven 时创建的 pom.xml 文件：

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>org.springframeworkgroupId>
    <artifactId>accessing-data-r2dbcartifactId>
    <version>0.1.0version>

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.2.2.RELEASEversion>
    parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot.experimentalgroupId>
            <artifactId>spring-boot-starter-data-r2dbcartifactId>
        dependency>
        <dependency>
            <groupId>io.r2dbcgroupId>
            <artifactId>r2dbc-h2artifactId>
            <scope>runtimescope>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
        <dependency>
            <groupId>org.springframework.boot.experimentalgroupId>
            <artifactId>spring-boot-test-autoconfigure-r2dbcartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>io.projectreactorgroupId>
            <artifactId>reactor-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot.experimentalgroupId>
                <artifactId>spring-boot-bom-r2dbcartifactId>
                <version>0.1.0.M3version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

    <properties>
        <java.version>1.8java.version>
    properties>

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

    <repositories>
        <repository>
            <id>spring-milestonesid>
            <name>Spring Milestonesname>
            <url>https://repo.spring.io/milestoneurl>
        repository>
    repositories>

project>

以下清单显示了在选择 Gradle 时创建的 build.gradle 文件：

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

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

repositories {
	mavenCentral()
	maven { url 'https://repo.spring.io/milestone' }
}

dependencies {
	implementation 'org.springframework.boot.experimental:spring-boot-starter-data-r2dbc'
	runtimeOnly 'com.h2database:h2'
	runtimeOnly 'io.r2dbc:r2dbc-h2'
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
	testImplementation 'org.springframework.boot.experimental:spring-boot-test-autoconfigure-r2dbc'
	testImplementation 'io.projectreactor:reactor-test'
}

dependencyManagement {
	imports {
		mavenBom 'org.springframework.boot.experimental:spring-boot-bom-r2dbc:0.1.0.M3'
	}
}

test {
	useJUnitPlatform()
}

 

定义模式

在该示例中，我们存储了 Customer 对象，每个对象都标注为 R2DBC 实体。以下清单显示了 SQL 模式类（在 src/main/resources/schema.sql 中）：

CREATE TABLE customer (id SERIAL PRIMARY KEY, first_name VARCHAR(255), last_name VARCHAR(255));

在这里，你有一个包含三列的 customer 表：id、first_name 和 last_name。id 列是自动递增的，其他列遵循默认的蛇形命名模式。在应用启动期间，Spring Boot 的自动配置将选择 schema.sql 文件以初始化数据库架构。
 

定义简单实体

在该示例中，我们存储了 Customer 对象，每个对象都标注为 R2DBC 实体。以下清单显示了 Customer 类（在 src/main/java/com/example/accessingdatar2dbc/Customer.java）：

package com.example.accessingdatar2dbc;

import org.springframework.data.annotation.Id;

public class Customer {

    @Id
    private Long id;

    private final String firstName;

    private final String lastName;

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

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return this.firstName;
    }

    public String getLastName() {
        return this.lastName;
    }

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

这里，我们有一个具有三个属性的 Customer 类：id、firstName 和 lastName。对 Customer 类的注释最少。id 属性用 @Id 注释，以便 Spring Data R2DBC 可以识别主键。默认情况下，假定主键由数据库在 INSERT 上生成。

其他两个属性，firstName 和 lastName，未标注。假定它们被映射到与属性本身共享同名称的列。

方便的 toString() 方法可以打印出客户的属性。
 

创建简单查询

Spring Data R2DBC 专注于使用 R2DBC 作为将技术存储在关系数据库中的底层技术。它最引人注目的功能是可以在运行时从存储界面创建存储库实现的功能。

要查看其工作原理，请创建一个与 Customer 实体配合使用的存储库接口，如下清单（在 src/main/java/com/example/accessingdatar2dbc/CustomerRepository.java 中）所示：

package com.example.accessingdatar2dbc;

import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;

import reactor.core.publisher.Flux;

public interface CustomerRepository extends ReactiveCrudRepository<Customer, Long> {

    @Query("SELECT * FROM customer WHERE last_name = :lastname")
    Flux<Customer> findByLastName(String lastName);

}

CustomerRepository 扩展了 ReactiveCrudRepository 接口。在 ReactiveCrudRepository 的通用参数中制定了与之配合使用的实体类型和 ID（Customer 和 Long）。通过扩展 ReactiveCrudRepository，CustomerRepository 继承了集中用于处理 Customer 持久性的方法，包括使用响应类型保存、删除和查找 Customer 实体的方法。

Spring Data R2DBC 还允许我们通过使用 @Query 标注其他查询方法来定义它们。例如，CustomerRepository 包含 findByLastName() 方法。

在典型的 Java 应用中，我们可能希望编写一个实现 CustomerRepository 的类。但是，这就是使 Spring Data R2DBC 如此强大的原因：我们无需编写存储库接口的实现。当我们运行应用时，Spring Data R2DBC 将创建一个实现。

现在，我们可以连接该示例并查看其外观！
 

创建应用类

Spring Initializr 为应用创建一个简单的类。以下清单显示了 Initializr 为该示例创建的类（在 src/main/java/com/example/accessingdatar2dbc/AccessingDataR2dbcApplication.java 中）：

package com.example.accessingdatar2dbc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AccessingDataR2dbcApplication {

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

}

@SpringBootApplication 是一个便利的注解，它添加了以下所有内容：

• @Configuration：将类标注为应用上下文 Bean 定义的源；
• @EnableAutoConfiguration：告诉 Spring Boot 根据类路径配置、其他 bean 以及各种属性的配置来添加 bean；
• @ComponentScan：告知 Spring 在 com/example 包中寻找他组件、配置以及服务。

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

现在，我们需要修改 Initializr 为我们创建的简单类。要获得输出（在该示例中为控制台），我们需要设置一个记录器。然后，我们需要设置一些数据并将其用于生成输出。以下清单显示了完成的 AccessingDataR2dbcApplication 类（在 src/main/java/com/example/accessingdatar2dbc/AccessingDataR2dbcApplication.java 中）：

package com.example.accessingdatar2dbc;

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.context.annotation.Bean;

import java.time.Duration;
import java.util.Arrays;

@SpringBootApplication
public class AccessingDataR2dbcApplication {

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

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

    @Bean
    public CommandLineRunner demo(CustomerRepository repository) {

        return (args) -> {
            // save a few customers
            repository.saveAll(Arrays.asList(new Customer("Jack", "Bauer"),
                new Customer("Chloe", "O'Brian"),
                new Customer("Kim", "Bauer"),
                new Customer("David", "Palmer"),
                new Customer("Michelle", "Dessler")))
                .blockLast(Duration.ofSeconds(10));

            // fetch all customers
            log.info("Customers found with findAll():");
            log.info("-------------------------------");
            repository.findAll().doOnNext(customer -> {
                log.info(customer.toString());
            }).blockLast(Duration.ofSeconds(10));

            log.info("");

            // fetch an individual customer by ID
			repository.findById(1L).doOnNext(customer -> {
				log.info("Customer found with findById(1L):");
				log.info("--------------------------------");
				log.info(customer.toString());
				log.info("");
			}).block(Duration.ofSeconds(10));


            // fetch customers by last name
            log.info("Customer found with findByLastName('Bauer'):");
            log.info("--------------------------------------------");
            repository.findByLastName("Bauer").doOnNext(bauer -> {
                log.info(bauer.toString());
            }).blockLast(Duration.ofSeconds(10));;
            log.info("");
        };
    }

}

AccessingDataR2dbcApplication 包含 main() 方法，该方法使 CustomerRepository 经过一些测试。首先，它从 Spring 应用上下文中获取 CustomerRepository。然后，它保存了少量 Customer 对象，演示了 save() 方法并设置了一些要使用的数据。接下来，它调用 findAll() 从数据库中获取所有 Customer 对象。然后，它调用 findById() 以通过其 ID 提取单个 Customer。最后，它调用 findByLastName() 来查找姓氏为 “Bauer” 的所有客户。

R2DBC 是一种反应式编程技术。同时，我们在同步的命令式流程中使用它，这就是为什么我们需要将每个调用与 block(...) 方法的变体进行同步。在典型的响应式应用中，生成的 Mono 或 Flux 将代表一系列操作符，这些操作符被转交给订阅响应式序列而不会阻塞调用线程的 Web 控制器或事件处理器。

默认情况下，Spring Boot 启用 R2DBC 存储支持，并在 @SpringBootApplication 所在的包（及其子包）中查找。如果我们的配置不在可见的软件包中有 R2DBC 存储库接口定义，则可以使用 @EnableR2dbcRepositories 及其类型安全的 basePackageClasses=MyRepository.class 参数来指出备用软件包。

 

构建可执行 JAR

我们可以结合 Gradle 或 Maven 来从命令行运行该应用。我们还可以构建一个包含所有必须依赖项、类以及资源的可执行 JAR 文件，然后运行该文件。在整个开发生命周期中，跨环境等等情况下，构建可执行 JAR 可以轻松地将服务作为应用进行发布、版本化以及部署。

如果使用 Gradle，则可以借助 ./gradlew bootRun 来运行应用。或通过借助 ./gradlew build 来构建 JAR 文件，然后运行 JAR 文件，如下所示：

java -jar build/libs/gs-accessing-data-r2dbc-0.1.0.jar

由官网提供的以上这条命令的执行结果与我本地的不一样，我需要这样才能运行：java -jar build/libs/initial-0.0.1-SNAPSHOT.jar。

如果使用 Maven，则可以借助 ./mvnw spring-boot:run 来运行该用。或可以借助 ./mvnw clean package 来构建 JAR 文件，然后运行 JAR 文件，如下所示：

java -jar target/gs-accessing-data-r2dbc-0.1.0.jar

由官网提供的以上这条命令的执行结果与我本地的不一样，我需要这样才能运行：java -jar target/accessing-data-r2dbc-0.1.0.jar。

我们还可以将 JAR 应用转换成 WAR 应用。

运行应用时，应该看到类似于以下内容的输出：

== Customers found with findAll():
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=2, firstName='Chloe', lastName='O'Brian']
Customer[id=3, firstName='Kim', lastName='Bauer']
Customer[id=4, firstName='David', lastName='Palmer']
Customer[id=5, firstName='Michelle', lastName='Dessler']

== Customer found with findOne(1L):
Customer[id=1, firstName='Jack', lastName='Bauer']

== Customer found with findByLastName('Bauer'):
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=3, firstName='Kim', lastName='Bauer']

 

概述

恭喜你！我们已经编写了一个简单的应用，该应用使用 Spring Data R2DBC 将对象保存到数据库中并从数据库中获取对象，而所有这些都无需编写具体的存储库实现。
 

参见

以下指南也可能会有所帮助：

• 使用 Redis 反应式访问数据

想看指南的其他内容？请访问该指南的所属专栏：《Spring 官方指南》