SQL 数据库

The Spring Framework provides extensive support for working with SQL databases, from direct JDBC access using JdbcClient or JdbcTemplate to complete “object relational mapping” technologies such as Hibernate. Spring Data provides an additional level of functionality: creating Repository implementations directly from interfaces and using conventions to generate queries from your method names.

配置数据源

Java 的 javax.sql.DataSource 接口提供了一种与数据库连接交互的标准方法。传统上，DataSource 使用 URL 以及一些凭据来建立数据库连接。

有关更高级示例，请参阅 “操作指南”部分，这些示例通常用于完全控制数据源的配置。

嵌入式数据库支持

使用内存中的嵌入式数据库开发应用程序通常很方便。显然，内存数据库不提供持久存储。您需要在应用程序启动时填充数据库，并准备好丢弃应用程序结束时的所有数据。

“操作指南”部分包含一个 关于如何初始化数据库的部分。

Spring Boot 可以自动配置嵌入式 H2、HSQL 和 Derby 数据库。您无需提供任何连接 URL。您只需要包含您要使用的嵌入式数据库的构建依赖项。如果类路径上有多个嵌入式数据库，请设置 spring.datasource.embedded-database-connection 配置属性来控制使用哪个数据库。将该属性设置为 none 将禁用嵌入式数据库的自动配置。

如果您在测试中使用此功能，您可能会注意到，无论您使用多少个应用程序上下文，整个测试套件都会重用同一个数据库。如果您想确保每个上下文都有一个单独的嵌入式数据库，您应该将 spring.datasource.generate-unique-name 设置为 true。

例如，典型的 POM 依赖项如下所示

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
	<groupId>org.hsqldb</groupId>
	<artifactId>hsqldb</artifactId>
	<scope>runtime</scope>
</dependency>
您需要依赖 spring-jdbc 才能自动配置嵌入式数据库。在本例中，它通过 spring-boot-starter-data-jpa 传递性地拉入。
如果出于任何原因，您确实为嵌入式数据库配置了连接 URL，请务必确保已禁用数据库的自动关闭。如果您使用 H2，您应该使用 DB_CLOSE_ON_EXIT=FALSE 来做到这一点。如果您使用 HSQLDB，您应该确保没有使用 shutdown=true。禁用数据库的自动关闭可以让 Spring Boot 控制何时关闭数据库，从而确保在不再需要访问数据库时关闭数据库。

连接到生产数据库

生产数据库连接也可以通过使用池化的 DataSource 自动配置。

DataSource 配置

DataSource 配置由 spring.datasource.* 中的外部配置属性控制。例如，您可以在 application.properties 中声明以下部分

  • 属性

  • YAML

spring.datasource.url=jdbc:mysql://127.0.0.1/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring:
  datasource:
    url: "jdbc:mysql://127.0.0.1/test"
    username: "dbuser"
    password: "dbpass"
您至少应该通过设置 spring.datasource.url 属性来指定 URL。否则，Spring Boot 会尝试自动配置嵌入式数据库。
Spring Boot 可以从大多数数据库的 URL 中推断出 JDBC 驱动程序类。如果您需要指定特定的类，您可以使用 spring.datasource.driver-class-name 属性。
为了创建池化的 DataSource，我们需要能够验证有效的 Driver 类是否可用，因此我们在执行任何操作之前都会检查这一点。换句话说，如果您设置 spring.datasource.driver-class-name=com.mysql.jdbc.Driver，那么该类必须是可加载的。

有关支持的更多选项，请参见 DataSourceProperties。这些是无论 实际实现 都有效的标准选项。还可以通过使用它们各自的前缀（spring.datasource.hikari.*、spring.datasource.tomcat.*、spring.datasource.dbcp2.* 和 spring.datasource.oracleucp.*）来微调特定于实现的设置。有关更多详细信息，请参见您正在使用的连接池实现的文档。

例如，如果您使用 Tomcat 连接池，您可以自定义许多其他设置，如下面的示例所示

  • 属性

  • YAML

spring.datasource.tomcat.max-wait=10000
spring.datasource.tomcat.max-active=50
spring.datasource.tomcat.test-on-borrow=true
spring:
  datasource:
    tomcat:
      max-wait: 10000
      max-active: 50
      test-on-borrow: true

这将设置池在没有可用连接的情况下等待 10000 毫秒后抛出异常，将最大连接数限制为 50，并在从池中借用连接之前验证连接。

支持的连接池

Spring Boot 使用以下算法来选择特定的实现

  1. 我们更喜欢 HikariCP，因为它具有高性能和并发性。如果 HikariCP 可用，我们始终选择它。

  2. 否则，如果 Tomcat 池化 DataSource 可用，我们将使用它。

  3. 否则，如果 Commons DBCP2 可用，我们将使用它。

  4. 如果 HikariCP、Tomcat 和 DBCP2 都不可用，并且 Oracle UCP 可用，我们将使用它。

如果您使用 spring-boot-starter-jdbc 或 spring-boot-starter-data-jpa “启动器”，您将自动获得对 HikariCP 的依赖关系。

您可以完全绕过该算法，并通过设置 spring.datasource.type 属性来指定要使用的连接池。如果您在 Tomcat 容器中运行应用程序，这尤其重要，因为 tomcat-jdbc 默认提供。

始终可以使用 DataSourceBuilder 手动配置其他连接池。如果您定义了自己的 DataSource bean，则不会发生自动配置。以下连接池受 DataSourceBuilder 支持

  • HikariCP

  • Tomcat 池化 DataSource

  • Commons DBCP2

  • Oracle UCP & OracleDataSource

  • Spring Framework 的 SimpleDriverDataSource

  • H2 JdbcDataSource

  • PostgreSQL PGSimpleDataSource

  • C3P0

连接到 JNDI DataSource

如果您将 Spring Boot 应用程序部署到应用程序服务器，您可能希望使用应用程序服务器的内置功能配置和管理您的 DataSource，并使用 JNDI 访问它。

spring.datasource.jndi-name 属性可以用作 spring.datasource.url、spring.datasource.username 和 spring.datasource.password 属性的替代方案，以从特定 JNDI 位置访问 DataSource。例如，application.properties 中的以下部分展示了如何访问 JBoss AS 定义的 DataSource

  • 属性

  • YAML

spring.datasource.jndi-name=java:jboss/datasources/customers
spring:
  datasource:
    jndi-name: "java:jboss/datasources/customers"

使用 JdbcTemplate

Spring 的 JdbcTemplate 和 NamedParameterJdbcTemplate 类是自动配置的，您可以将它们 @Autowire 直接注入到您自己的 bean 中，如以下示例所示

  • Java

  • Kotlin

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

	private final JdbcTemplate jdbcTemplate;

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

	public void doSomething() {
		this.jdbcTemplate ...
	}

}
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val jdbcTemplate: JdbcTemplate) {

	fun doSomething() {
		jdbcTemplate.execute("delete from customer")
	}

}

您可以使用 spring.jdbc.template.* 属性自定义模板的一些属性，如以下示例所示

  • 属性

  • YAML

spring.jdbc.template.max-rows=500
spring:
  jdbc:
    template:
      max-rows: 500
NamedParameterJdbcTemplate 在幕后重用相同的 JdbcTemplate 实例。如果定义了多个 JdbcTemplate 且不存在主要候选者，则不会自动配置 NamedParameterJdbcTemplate。

使用 JdbcClient

Spring 的 JdbcClient 是根据 NamedParameterJdbcTemplate 的存在自动配置的。您也可以将它直接注入到您自己的 bean 中，如以下示例所示

  • Java

  • Kotlin

import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

	private final JdbcClient jdbcClient;

	public MyBean(JdbcClient jdbcClient) {
		this.jdbcClient = jdbcClient;
	}

	public void doSomething() {
		this.jdbcClient ...
	}

}
import org.springframework.jdbc.core.simple.JdbcClient
import org.springframework.stereotype.Component

@Component
class MyBean(private val jdbcClient: JdbcClient) {

	fun doSomething() {
		jdbcClient.sql("delete from customer").update()
	}

}

如果您依赖自动配置来创建底层的 JdbcTemplate，则客户端也会考虑使用 spring.jdbc.template.* 属性进行的任何自定义。

JPA 和 Spring Data JPA

Java 持久性 API 是一种标准技术，允许您将对象“映射”到关系数据库。spring-boot-starter-data-jpa POM 提供了一种快速入门的方法。它提供了以下关键依赖项

  • Hibernate：最流行的 JPA 实现之一。

  • Spring Data JPA：帮助您实现基于 JPA 的存储库。

  • Spring ORM：来自 Spring 框架的核心 ORM 支持。

我们不会在这里详细介绍 JPA 或 Spring Data。您可以按照 “使用 JPA 访问数据” 指南从 spring.io 中学习，并阅读 Spring Data JPA 和 Hibernate 参考文档。

实体类

传统上，JPA 的“实体”类是在 persistence.xml 文件中指定的。使用 Spring Boot 时，此文件不再需要，而是使用“实体扫描”。默认情况下，会扫描 自动配置包。

任何使用 @Entity、@Embeddable 或 @MappedSuperclass 注解的类都被视为实体类。一个典型的实体类如下所示

  • Java

  • Kotlin

import java.io.Serializable;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

@Entity
public class City implements Serializable {

	@Id
	@GeneratedValue
	private Long id;

	@Column(nullable = false)
	private String name;

	@Column(nullable = false)
	private String state;

	// ... additional members, often include @OneToMany mappings

	protected City() {
		// no-args constructor required by JPA spec
		// this one is protected since it should not be used directly
	}

	public City(String name, String state) {
		this.name = name;
		this.state = state;
	}

	public String getName() {
		return this.name;
	}

	public String getState() {
		return this.state;
	}

	// ... etc

}
import jakarta.persistence.Column
import jakarta.persistence.Entity
import jakarta.persistence.GeneratedValue
import jakarta.persistence.Id
import java.io.Serializable

@Entity
class City : Serializable {

	@Id
	@GeneratedValue
	private val id: Long? = null

	@Column(nullable = false)
	var name: String? = null
		private set

	// ... etc
	@Column(nullable = false)
	var state: String? = null
		private set

	// ... additional members, often include @OneToMany mappings

	protected constructor() {
		// no-args constructor required by JPA spec
		// this one is protected since it should not be used directly
	}

	constructor(name: String?, state: String?) {
		this.name = name
		this.state = state
	}

}
可以使用 @EntityScan 注解自定义实体扫描位置。请参阅“将 @Entity 定义与 Spring 配置分离”指南。

Spring Data JPA 仓库

Spring Data JPA 仓库是您可以定义的接口，用于访问数据。JPA 查询会根据您的方法名称自动创建。例如，CityRepository 接口可以声明一个 findAllByState(String state) 方法来查找给定州的所有城市。

对于更复杂的查询，可以使用 Spring Data 的 Query 注解来注解您的方法。

Spring Data 仓库通常继承自 Repository 或 CrudRepository 接口。如果您使用自动配置，则会搜索 自动配置包 中的仓库。

可以使用 @EnableJpaRepositories 自定义要查找仓库的位置。

以下示例显示了一个典型的 Spring Data 仓库接口定义

  • Java

  • Kotlin

import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.City;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.Repository;

public interface CityRepository extends Repository<City, Long> {

	Page<City> findAll(Pageable pageable);

	City findByNameAndStateAllIgnoringCase(String name, String state);

}
import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.City
import org.springframework.data.domain.Page
import org.springframework.data.domain.Pageable
import org.springframework.data.repository.Repository

interface CityRepository : Repository<City?, Long?> {

	fun findAll(pageable: Pageable?): Page<City?>?

	fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): City?

}

Spring Data JPA 仓库支持三种不同的引导模式：默认、延迟和懒加载。要启用延迟或懒加载引导，将 spring.data.jpa.repositories.bootstrap-mode 属性分别设置为 deferred 或 lazy。使用延迟或懒加载引导时，自动配置的 EntityManagerFactoryBuilder 将使用上下文的 AsyncTaskExecutor（如果有）作为引导执行器。如果存在多个执行器，则将使用名为 applicationTaskExecutor 的执行器。

使用延迟或懒加载引导时，请确保在应用程序上下文引导阶段之后延迟对 JPA 基础设施的任何访问。可以使用 SmartInitializingSingleton 来调用需要 JPA 基础设施的任何初始化。对于作为 Spring bean 创建的 JPA 组件（如转换器），请使用 ObjectProvider 来延迟依赖项（如果有）的解析。
我们仅仅触及了 Spring Data JPA 的表面。有关完整详细信息，请参阅 Spring Data JPA 参考文档。

Spring Data Envers 存储库

如果 Spring Data Envers 可用，JPA 存储库将自动配置为支持典型的 Envers 查询。

要使用 Spring Data Envers，请确保您的存储库扩展自 RevisionRepository，如以下示例所示

  • Java

  • Kotlin

import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.Country;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.history.RevisionRepository;

public interface CountryRepository extends RevisionRepository<Country, Long, Integer>, Repository<Country, Long> {

	Page<Country> findAll(Pageable pageable);

}
import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.Country
import org.springframework.data.domain.Page
import org.springframework.data.domain.Pageable
import org.springframework.data.repository.Repository
import org.springframework.data.repository.history.RevisionRepository

interface CountryRepository :
		RevisionRepository<Country?, Long?, Int>,
		Repository<Country?, Long?> {

	fun findAll(pageable: Pageable?): Page<Country?>?

}
有关更多详细信息，请查看 Spring Data Envers 参考文档。

创建和删除 JPA 数据库

默认情况下，JPA 数据库仅在您使用嵌入式数据库（H2、HSQL 或 Derby）时才会自动创建。您可以使用 spring.jpa.* 属性显式配置 JPA 设置。例如，要创建和删除表，您可以将以下行添加到您的 application.properties 中

  • 属性

  • YAML

spring.jpa.hibernate.ddl-auto=create-drop
spring:
  jpa:
    hibernate.ddl-auto: "create-drop"
Hibernate 自身的内部属性名称（如果您碰巧记得它）是 hibernate.hbm2ddl.auto。您可以使用 spring.jpa.properties.* 设置它以及其他 Hibernate 本地属性（在添加到实体管理器之前会剥离前缀）。以下行显示了设置 Hibernate 的 JPA 属性的示例

  • 属性

  • YAML

spring.jpa.properties.hibernate.globally_quoted_identifiers=true
spring:
  jpa:
    properties:
      hibernate:
        "globally_quoted_identifiers": "true"

前面的示例中的行将 hibernate.globally_quoted_identifiers 属性的值传递给 Hibernate 实体管理器。

默认情况下，DDL 执行（或验证）将延迟到 ApplicationContext 启动后。

在视图中打开实体管理器

如果您正在运行 Web 应用程序，Spring Boot 默认情况下会注册 OpenEntityManagerInViewInterceptor 以应用“在视图中打开实体管理器”模式，以允许在 Web 视图中进行延迟加载。如果您不希望这种行为，您应该在您的 application.properties 中将 spring.jpa.open-in-view 设置为 false。

Spring Data JDBC

Spring Data 包含对 JDBC 的存储库支持，并将自动为CrudRepository上的方法生成 SQL。 对于更高级的查询，提供了一个@Query注释。

当类路径上有必要的依赖项时，Spring Boot 将自动配置 Spring Data 的 JDBC 存储库。 它们可以通过对spring-boot-starter-data-jdbc的单个依赖项添加到您的项目中。 如果需要，您可以通过添加@EnableJdbcRepositories注释或AbstractJdbcConfiguration子类到您的应用程序来控制 Spring Data JDBC 的配置。

有关 Spring Data JDBC 的完整详细信息，请参阅参考文档。

使用 H2 的 Web 控制台

H2 数据库提供了一个基于浏览器的控制台，Spring Boot 可以为您自动配置。 当满足以下条件时，控制台将自动配置

  • 您正在开发基于 servlet 的 Web 应用程序。

  • com.h2database:h2在类路径上。

  • 您正在使用Spring Boot 的开发工具。

如果您没有使用 Spring Boot 的开发工具，但仍然希望使用 H2 的控制台，您可以将spring.h2.console.enabled属性配置为true。
H2 控制台仅用于开发，因此您应该注意确保spring.h2.console.enabled在生产环境中未设置为true。

更改 H2 控制台的路径

默认情况下，控制台位于/h2-console。 您可以使用spring.h2.console.path属性自定义控制台的路径。

在安全应用程序中访问 H2 控制台

H2 控制台使用框架，并且由于它仅用于开发，因此没有实现 CSRF 防护措施。 如果您的应用程序使用 Spring Security，您需要配置它以

  • 对针对控制台的请求禁用 CSRF 防护，

  • 在来自控制台的响应中将标头X-Frame-Options设置为SAMEORIGIN。

有关CSRF和标头X-Frame-Options的更多信息，请参阅 Spring Security 参考指南。

在简单的设置中，可以使用以下SecurityFilterChain

  • Java

  • Kotlin

import org.springframework.boot.autoconfigure.security.servlet.PathRequest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Profile("dev")
@Configuration(proxyBeanMethods = false)
public class DevProfileSecurityConfiguration {

	@Bean
	@Order(Ordered.HIGHEST_PRECEDENCE)
	SecurityFilterChain h2ConsoleSecurityFilterChain(HttpSecurity http) throws Exception {
		http.securityMatcher(PathRequest.toH2Console());
		http.authorizeHttpRequests(yourCustomAuthorization());
		http.csrf((csrf) -> csrf.disable());
		http.headers((headers) -> headers.frameOptions((frame) -> frame.sameOrigin()));
		return http.build();
	}


}
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Profile
import org.springframework.core.Ordered
import org.springframework.core.annotation.Order
import org.springframework.security.config.Customizer
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.web.SecurityFilterChain

@Profile("dev")
@Configuration(proxyBeanMethods = false)
class DevProfileSecurityConfiguration {

	@Bean
	@Order(Ordered.HIGHEST_PRECEDENCE)
	fun h2ConsoleSecurityFilterChain(http: HttpSecurity): SecurityFilterChain {
		return http.authorizeHttpRequests(yourCustomAuthorization())
			.csrf { csrf -> csrf.disable() }
			.headers { headers -> headers.frameOptions { frameOptions -> frameOptions.sameOrigin() } }
			.build()
	}


}
H2 控制台仅供开发使用。在生产环境中，禁用 CSRF 保护或允许网站框架可能会造成严重的安全风险。
PathRequest.toH2Console() 方法即使在控制台路径被自定义的情况下也能返回正确的请求匹配器。

使用 jOOQ

jOOQ 面向对象查询 (jOOQ) 是 Data Geekery 的一款流行产品，它可以从您的数据库生成 Java 代码，并通过其流畅的 API 构建类型安全的 SQL 查询。商业版和开源版都可以与 Spring Boot 一起使用。

代码生成

为了使用 jOOQ 类型安全的查询，您需要从数据库模式生成 Java 类。您可以按照 jOOQ 用户手册 中的说明进行操作。如果您使用 jooq-codegen-maven 插件，并且也使用 spring-boot-starter-parent “父 POM”，则可以安全地省略插件的 <version> 标签。您还可以使用 Spring Boot 定义的版本变量（例如 h2.version）来声明插件的数据库依赖项。以下清单显示了一个示例

<plugin>
	<groupId>org.jooq</groupId>
	<artifactId>jooq-codegen-maven</artifactId>
	<executions>
		...
	</executions>
	<dependencies>
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<version>${h2.version}</version>
		</dependency>
	</dependencies>
	<configuration>
		<jdbc>
			<driver>org.h2.Driver</driver>
			<url>jdbc:h2:~/yourdatabase</url>
		</jdbc>
		<generator>
			...
		</generator>
	</configuration>
</plugin>

使用 DSLContext

jOOQ 提供的流畅 API 通过 org.jooq.DSLContext 接口启动。Spring Boot 自动配置一个 DSLContext 作为 Spring Bean，并将其连接到您的应用程序 DataSource。要使用 DSLContext，您可以将其注入，如以下示例所示

  • Java

  • Kotlin

import java.util.GregorianCalendar;
import java.util.List;

import org.jooq.DSLContext;

import org.springframework.stereotype.Component;

import static org.springframework.boot.docs.data.sql.jooq.dslcontext.Tables.AUTHOR;

@Component
public class MyBean {

	private final DSLContext create;

	public MyBean(DSLContext dslContext) {
		this.create = dslContext;
	}


}
import org.jooq.DSLContext
import org.springframework.stereotype.Component
import java.util.GregorianCalendar

@Component
class MyBean(private val create: DSLContext) {


}
jOOQ 手册倾向于使用名为 create 的变量来保存 DSLContext。

然后，您可以使用 DSLContext 来构建您的查询，如以下示例所示

  • Java

  • Kotlin

	public List<GregorianCalendar> authorsBornAfter1980() {
		return this.create.selectFrom(AUTHOR)
			.where(AUTHOR.DATE_OF_BIRTH.greaterThan(new GregorianCalendar(1980, 0, 1)))
			.fetch(AUTHOR.DATE_OF_BIRTH);
	fun authorsBornAfter1980(): List<GregorianCalendar> {
		return create.selectFrom<Tables.TAuthorRecord>(Tables.AUTHOR)
			.where(Tables.AUTHOR?.DATE_OF_BIRTH?.greaterThan(GregorianCalendar(1980, 0, 1)))
			.fetch(Tables.AUTHOR?.DATE_OF_BIRTH)
	}

jOOQ SQL 方言

除非已配置 spring.jooq.sql-dialect 属性，否则 Spring Boot 会确定要用于数据源的 SQL 方言。如果 Spring Boot 无法检测到方言，它将使用 DEFAULT。

Spring Boot 只能自动配置 jOOQ 开源版本支持的方言。

自定义 jOOQ

可以通过定义您自己的 DefaultConfigurationCustomizer bean 来实现更高级的自定义，该 bean 将在创建 org.jooq.Configuration @Bean 之前被调用。这优先于自动配置应用的任何内容。

如果您想完全控制 jOOQ 配置，还可以创建您自己的 org.jooq.Configuration @Bean。

使用 R2DBC

Reactive Relational Database Connectivity (R2DBC) 项目将反应式编程 API 带到了关系数据库。R2DBC 的 io.r2dbc.spi.Connection 提供了一种使用非阻塞数据库连接的标准方法。连接是通过使用 ConnectionFactory 提供的，类似于使用 jdbc 的 DataSource。

ConnectionFactory 的配置由 spring.r2dbc.* 中的外部配置属性控制。例如，您可以在 application.properties 中声明以下部分

  • 属性

  • YAML

spring.r2dbc.url=r2dbc:postgresql://127.0.0.1/test
spring.r2dbc.username=dbuser
spring.r2dbc.password=dbpass
spring:
  r2dbc:
    url: "r2dbc:postgresql://127.0.0.1/test"
    username: "dbuser"
    password: "dbpass"
您不需要指定驱动程序类名，因为 Spring Boot 会从 R2DBC 的连接工厂发现中获取驱动程序。
至少应提供 URL。URL 中指定的信息优先于各个属性，即 name、username、password 和池选项。
“操作方法”部分包含一个 关于如何初始化数据库的部分。

要自定义由 ConnectionFactory 创建的连接，即设置您不想（或不能）在中央数据库配置中配置的特定参数，可以使用 ConnectionFactoryOptionsBuilderCustomizer @Bean。以下示例展示了如何在保留应用程序配置中的其他选项的同时手动覆盖数据库端口

  • Java

  • Kotlin

import io.r2dbc.spi.ConnectionFactoryOptions;

import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyR2dbcConfiguration {

	@Bean
	public ConnectionFactoryOptionsBuilderCustomizer connectionFactoryPortCustomizer() {
		return (builder) -> builder.option(ConnectionFactoryOptions.PORT, 5432);
	}

}
import io.r2dbc.spi.ConnectionFactoryOptions
import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyR2dbcConfiguration {

	@Bean
	fun connectionFactoryPortCustomizer(): ConnectionFactoryOptionsBuilderCustomizer {
		return ConnectionFactoryOptionsBuilderCustomizer { builder ->
			builder.option(ConnectionFactoryOptions.PORT, 5432)
		}
	}

}

以下示例展示了如何设置一些 PostgreSQL 连接选项

  • Java

  • Kotlin

import java.util.HashMap;
import java.util.Map;

import io.r2dbc.postgresql.PostgresqlConnectionFactoryProvider;

import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyPostgresR2dbcConfiguration {

	@Bean
	public ConnectionFactoryOptionsBuilderCustomizer postgresCustomizer() {
		Map<String, String> options = new HashMap<>();
		options.put("lock_timeout", "30s");
		options.put("statement_timeout", "60s");
		return (builder) -> builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options);
	}

}
import io.r2dbc.postgresql.PostgresqlConnectionFactoryProvider
import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyPostgresR2dbcConfiguration {

	@Bean
	fun postgresCustomizer(): ConnectionFactoryOptionsBuilderCustomizer {
		val options: MutableMap<String, String> = HashMap()
		options["lock_timeout"] = "30s"
		options["statement_timeout"] = "60s"
		return ConnectionFactoryOptionsBuilderCustomizer { builder ->
			builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options)
		}
	}

}

当 ConnectionFactory bean 可用时，常规 JDBC DataSource 自动配置将退回。如果您想保留 JDBC DataSource 自动配置，并且乐于在响应式应用程序中使用阻塞式 JDBC API 的风险，请在应用程序中的 @Configuration 类上添加 @Import(DataSourceAutoConfiguration.class) 以重新启用它。

嵌入式数据库支持

与 JDBC 支持 类似，Spring Boot 可以自动配置嵌入式数据库以供响应式使用。您无需提供任何连接 URL。您只需要包含对要使用的嵌入式数据库的构建依赖项，如以下示例所示

<dependency>
	<groupId>io.r2dbc</groupId>
	<artifactId>r2dbc-h2</artifactId>
	<scope>runtime</scope>
</dependency>

如果您在测试中使用此功能，您可能会注意到，无论您使用多少个应用程序上下文，整个测试套件都会重用同一个数据库。如果您想确保每个上下文都有一个单独的嵌入式数据库，您应该将 spring.r2dbc.generate-unique-name 设置为 true。

使用 DatabaseClient

DatabaseClient bean 会自动配置，您可以直接将其 @Autowire 到您自己的 bean 中，如以下示例所示

  • Java

  • Kotlin

import java.util.Map;

import reactor.core.publisher.Flux;

import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

	private final DatabaseClient databaseClient;

	public MyBean(DatabaseClient databaseClient) {
		this.databaseClient = databaseClient;
	}

	// ...

	public Flux<Map<String, Object>> someMethod() {
		return this.databaseClient.sql("select * from user").fetch().all();
	}

}
import org.springframework.r2dbc.core.DatabaseClient
import org.springframework.stereotype.Component
import reactor.core.publisher.Flux

@Component
class MyBean(private val databaseClient: DatabaseClient) {

	// ...

	fun someMethod(): Flux<Map<String, Any>> {
		return databaseClient.sql("select * from user").fetch().all()
	}

}

Spring Data R2DBC 存储库

Spring Data R2DBC 存储库是您可以定义的用于访问数据的接口。查询会根据您的方法名称自动创建。例如，一个 CityRepository 接口可以声明一个 findAllByState(String state) 方法来查找给定州的所有城市。

对于更复杂的查询，您可以使用 Spring Data 的 Query 注解来注解您的方法。

Spring Data 仓库通常继承自 Repository 或 CrudRepository 接口。如果您使用自动配置，则会搜索 自动配置包 中的仓库。

以下示例显示了一个典型的 Spring Data 仓库接口定义

  • Java

  • Kotlin

import reactor.core.publisher.Mono;

import org.springframework.data.repository.Repository;

public interface CityRepository extends Repository<City, Long> {

	Mono<City> findByNameAndStateAllIgnoringCase(String name, String state);

}
import org.springframework.data.repository.Repository
import reactor.core.publisher.Mono

interface CityRepository : Repository<City?, Long?> {

	fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): Mono<City?>?

}
我们只是简单地介绍了 Spring Data R2DBC。有关完整详细信息，请参阅 Spring Data R2DBC 参考文档。