SQL Databases _ Spring Boot 3.3.2-SNAPSHOT 中文文档(官方文档中文翻译) —

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.1！Spring中文文档

Spring Framework 为使用 SQL 数据库提供了广泛的支持，从使用直接 JDBC 访问到完成“对象关系映射”技术（如 Hibernate）。Spring Data 提供了额外的功能：直接从接口创建实现，并使用约定从方法名称生成查询。JdbcClientJdbcTemplateRepositorySpring中文文档

配置数据源

Java 的接口提供了一种处理数据库连接的标准方法。传统上，a 使用 a 和一些凭据来建立数据库连接。javax.sql.DataSourceDataSourceURLSpring中文文档

有关更高级的示例，请参阅“操作方法”部分，通常用于完全控制 DataSource 的配置。

嵌入式数据库支持

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

“操作方法”部分包括有关如何初始化数据库的部分。

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

如果在测试中使用此功能，您可能会注意到，无论使用的应用程序上下文数量如何，整个测试套件都会重复使用相同的数据库。如果要确保每个上下文都有一个单独的嵌入式数据库，则应设置为。spring.datasource.generate-unique-nametrueSpring中文文档

例如，典型的 POM 依赖项如下所示：Spring中文文档

<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>

您需要依赖 on 才能自动配置嵌入式数据库。在此示例中，它通过传递方式拉入。spring-jdbcspring-boot-starter-data-jpa

无论出于何种原因，如果确实为嵌入式数据库配置了连接 URL，请注意确保禁用数据库的自动关闭功能。如果使用 H2，则应使用 H2。如果使用 HSQLDB，则应确保未使用它。禁用数据库的自动关闭功能可以让 Spring Boot 控制数据库何时关闭，从而确保一旦不再需要访问数据库，它就会发生。DB_CLOSE_ON_EXIT=FALSEshutdown=true

连接到生产数据库

还可以使用池自动配置生产数据库连接。DataSourceSpring中文文档

数据源配置

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

PropertiesSpring中文文档
YAMLSpring中文文档

spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass

spring:
  datasource:
    url: "jdbc:mysql://localhost/test"
    username: "dbuser"
    password: "dbpass"

您至少应通过设置属性来指定 URL。否则，Spring Boot 会尝试自动配置嵌入式数据库。spring.datasource.url

Spring Boot 可以从 URL 中推断出大多数数据库的 JDBC 驱动程序类。如果需要指定特定类，可以使用该属性。spring.datasource.driver-class-name

对于要创建的池，我们需要能够验证有效的类是否可用，因此我们在执行任何操作之前都会检查它。换句话说，如果设置了，那么该类必须是可加载的。DataSourceDriverspring.datasource.driver-class-name=com.mysql.jdbc.Driver

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

例如，如果使用 Tomcat 连接池，则可以自定义许多其他设置，如以下示例所示：Spring中文文档

PropertiesSpring中文文档
YAMLSpring中文文档

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中文文档

支持的连接池

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

我们更喜欢 HikariCP 的性能和并发性。如果 HikariCP 可用，我们总是选择它。Spring中文文档
否则，如果 Tomcat 池可用，我们将使用它。DataSourceSpring中文文档
否则，如果 Commons DBCP2 可用，我们会使用它。Spring中文文档
如果 HikariCP、Tomcat 和 DBCP2 都不可用，并且 Oracle UCP 可用，我们将使用它。Spring中文文档

如果使用或 “starters”，则会自动获得对的依赖关系。spring-boot-starter-jdbcspring-boot-starter-data-jpaHikariCP

可以完全绕过该算法，并通过设置属性来指定要使用的连接池。如果在 Tomcat 容器中运行应用程序（默认情况下提供），这一点尤其重要。spring.datasource.typetomcat-jdbcSpring中文文档

始终可以使用手动配置其他连接池。如果定义自己的 Bean，则不会进行自动配置。以下连接池受以下支持：DataSourceBuilderDataSourceDataSourceBuilderSpring中文文档

光CPSpring中文文档
Tomcat 池化DataSourceSpring中文文档
共享资源 DBCP2Spring中文文档
甲骨文 UCP &OracleDataSourceSpring中文文档
Spring Framework 的SimpleDriverDataSourceSpring中文文档
H2型JdbcDataSourceSpring中文文档
PostgreSQL的PGSimpleDataSourceSpring中文文档
分子式：C3P0Spring中文文档

与 JNDI 数据源的连接

如果将 Spring Boot 应用程序部署到 Application Server，那么您可能希望使用 Application Server 的内置功能部件来配置和管理 DataSource，并使用 JNDI 访问它。Spring中文文档

该属性可以用作、和属性的替代项，以便从特定的 JNDI 位置访问。例如，下面的部分展示了如何访问定义的 JBoss ：spring.datasource.jndi-namespring.datasource.urlspring.datasource.usernamespring.datasource.passwordDataSourceapplication.propertiesDataSourceSpring中文文档

PropertiesSpring中文文档
YAMLSpring中文文档

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

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

有关更高级的示例，请参阅“操作方法”部分，通常用于完全控制 DataSource 的配置。

“操作方法”部分包括有关如何初始化数据库的部分。

您需要依赖 on 才能自动配置嵌入式数据库。在此示例中，它通过传递方式拉入。spring-jdbcspring-boot-starter-data-jpa

您至少应通过设置属性来指定 URL。否则，Spring Boot 会尝试自动配置嵌入式数据库。spring.datasource.url

Spring Boot 可以从 URL 中推断出大多数数据库的 JDBC 驱动程序类。如果需要指定特定类，可以使用该属性。spring.datasource.driver-class-name

如果使用或 “starters”，则会自动获得对的依赖关系。spring-boot-starter-jdbcspring-boot-starter-data-jpaHikariCP

使用 JdbcTemplate

Spring 和 classes 是自动配置的，您可以将它们直接放入自己的 Bean 中，如以下示例所示：JdbcTemplateNamedParameterJdbcTemplate@AutowireSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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.*Spring中文文档

PropertiesSpring中文文档
YAMLSpring中文文档

spring.jdbc.template.max-rows=500

spring:
  jdbc:
    template:
      max-rows: 500

在后台重用相同的实例。如果定义了多个，并且不存在主要候选者，则不会自动配置。NamedParameterJdbcTemplateJdbcTemplateJdbcTemplateNamedParameterJdbcTemplate

使用 JdbcClient

Spring 会根据 . 您也可以将其直接注入自己的 Bean 中，如以下示例所示：JdbcClientNamedParameterJdbcTemplateSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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()
	}

}

如果依靠自动配置来创建基础，则客户端中也会考虑使用属性的任何自定义。JdbcTemplatespring.jdbc.template.*Spring中文文档

JPA 和 Spring Data JPA

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

Hibernate：最流行的 JPA 实现之一。Spring中文文档
Spring Data JPA：帮助您实现基于 JPA 的存储库。Spring中文文档
Spring ORM：来自 Spring Framework 的核心 ORM 支持。Spring中文文档

我们在这里不赘述 JPA 或 Spring Data 的太多细节。您可以按照 spring.io 中的“使用 JPA 访问数据”指南并阅读 Spring Data JPA 和 Hibernate 参考文档。

实体类

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

任何用、或注释的类都将被考虑。典型的实体类类似于以下示例：@Entity@Embeddable@MappedSuperclassSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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
	}

}

您可以使用注释自定义实体扫描位置。请参阅“将@Entity定义与 Spring 配置分开”操作方法。@EntityScan

Spring Data JPA 存储库

Spring Data JPA 存储库是可以定义用于访问数据的接口。 JPA 查询是从方法名称自动创建的。例如，接口可以声明一种方法来查找给定状态中的所有城市。CityRepositoryfindAllByState(String state)Spring中文文档

对于更复杂的查询，您可以使用 Spring Data 的查询注释来注释您的方法。Spring中文文档

Spring Data 存储库通常从 Repository 或 CrudRepository 接口扩展。如果使用自动配置，则会在自动配置包中搜索存储库。Spring中文文档

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

以下示例显示了典型的 Spring Data 存储库接口定义：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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-modedeferredlazyEntityManagerFactoryBuilderAsyncTaskExecutorapplicationTaskExecutorSpring中文文档

使用延迟或延迟引导时，请确保在应用程序上下文引导阶段之后推迟对 JPA 基础架构的任何访问。您可以使用它来调用任何需要 JPA 基础结构的初始化。对于作为 Spring Bean 创建的 JPA 组件（如转换器），用于延迟依赖项的解析（如果有）。SmartInitializingSingletonObjectProviderSpring中文文档

我们几乎没有触及Spring Data JPA的表面。有关完整的详细信息，请参阅 Spring Data JPA 参考文档。

Spring Data Envers 存储库

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

要使用 Spring Data Envers，请确保存储库从以下示例中所示扩展：RevisionRepositorySpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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 数据库

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

PropertiesSpring中文文档
YAMLSpring中文文档

spring.jpa.hibernate.ddl-auto=create-drop

spring:
  jpa:
    hibernate.ddl-auto: "create-drop"

Hibernate 自己的内部属性名称（如果你碰巧记得更好的话）是。您可以使用以下方法将其与其他 Hibernate 本机属性一起设置（在将前缀添加到实体管理器之前将其剥离）。以下行显示了为 Hibernate 设置 JPA 属性的示例：hibernate.hbm2ddl.autospring.jpa.properties.*

PropertiesSpring中文文档
YAMLSpring中文文档

spring.jpa.properties.hibernate.globally_quoted_identifiers=true

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

前面示例中的行将 for 属性的值传递给 Hibernate 实体管理器。truehibernate.globally_quoted_identifiersSpring中文文档

默认情况下，DDL 执行（或验证）将推迟到启动。ApplicationContextSpring中文文档

在 View 中打开 EntityManager

如果运行的是 Web 应用程序，则 Spring Boot 默认注册 OpenEntityManagerInViewInterceptor 以应用“在视图中打开 EntityManager”模式，以允许在 Web 视图中延迟加载。如果不希望出现此行为，则应在 .spring.jpa.open-in-viewfalseapplication.propertiesSpring中文文档

我们在这里不赘述 JPA 或 Spring Data 的太多细节。您可以按照 spring.io 中的“使用 JPA 访问数据”指南并阅读 Spring Data JPA 和 Hibernate 参考文档。

您可以使用注释自定义实体扫描位置。请参阅“将@Entity定义与 Spring 配置分开”操作方法。@EntityScan

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

我们几乎没有触及Spring Data JPA的表面。有关完整的详细信息，请参阅 Spring Data JPA 参考文档。

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

Spring 数据 JDBC

Spring Data 包括对 JDBC 的存储库支持，并将自动为 . 对于更高级的查询，将提供注释。CrudRepository@QuerySpring中文文档

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

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

使用 H2 的 Web 控制台

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

您正在开发基于 servlet 的 Web 应用程序。Spring中文文档
com.h2database:h2位于类路径上。Spring中文文档
您正在使用 Spring Boot 的开发人员工具。Spring中文文档

如果您没有使用 Spring Boot 的开发人员工具，但仍想使用 H2 的控制台，则可以使用值来配置该属性。spring.h2.console.enabledtrue

H2 控制台仅用于开发期间，因此应注意确保未在生产环境中将其设置为。spring.h2.console.enabledtrue

更改 H2 控制台的路径

默认情况下，控制台位于。您可以使用该属性自定义控制台的路径。/h2-consolespring.h2.console.pathSpring中文文档

在受保护的应用程序中访问 H2 控制台

H2 控制台使用框架，并且由于它仅用于开发，因此不实施 CSRF 保护措施。如果您的应用程序使用 Spring Security，则需要将其配置为Spring中文文档

对针对控制台的请求禁用 CSRF 保护，Spring中文文档
将标头设置为控制台的 On Responses。X-Frame-OptionsSAMEORIGINSpring中文文档

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

在简单的设置中，可以使用如下所示：SecurityFilterChainSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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.config.annotation.web.configurers.CsrfConfigurer;
import org.springframework.security.config.annotation.web.configurers.HeadersConfigurer.FrameOptionsConfig;
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(CsrfConfigurer::disable);
		http.headers((headers) -> headers.frameOptions(FrameOptionsConfig::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()自定义控制台的路径时，也会返回正确的请求匹配器。

如果您没有使用 Spring Boot 的开发人员工具，但仍想使用 H2 的控制台，则可以使用值来配置该属性。spring.h2.console.enabledtrue

H2 控制台仅用于开发期间，因此应注意确保未在生产环境中将其设置为。spring.h2.console.enabledtrue

H2 控制台仅供开发期间使用。在生产环境中，禁用 CSRF 保护或允许网站框架可能会造成严重的安全风险。

PathRequest.toH2Console()自定义控制台的路径时，也会返回正确的请求匹配器。

使用 jOOQ

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

代码生成

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

<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 提供的 Fluent API 是通过接口启动的。 Spring Boot 自动将 a 配置为 Spring Bean 并将其连接到您的应用程序。要使用，可以注入它，如以下示例所示：org.jooq.DSLContextDSLContextDataSourceDSLContextSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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 手册倾向于使用一个名为 .createDSLContext

然后，可以使用来构造查询，如以下示例所示：DSLContextSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

	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 Boot 将确定要用于数据源的 SQL 方言。如果 Spring Boot 无法检测到方言，则使用 .spring.jooq.sql-dialectDEFAULTSpring中文文档

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

自定义 jOOQ

通过定义您自己的 Bean，可以在创建 . 这优先于自动配置应用的任何内容。DefaultConfigurationCustomizerorg.jooq.Configuration@BeanSpring中文文档

如果您想完全控制 jOOQ 配置，也可以创建自己的配置。org.jooq.Configuration@BeanSpring中文文档

jOOQ 手册倾向于使用一个名为 .createDSLContext

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

使用 R2DBC

响应式关系数据库连接（R2DBC）项目为关系数据库带来了响应式编程 API。 R2DBC 提供了一种使用非阻塞数据库连接的标准方法。连接是通过使用提供的，类似于 a 和 jdbc 的连接。io.r2dbc.spi.ConnectionConnectionFactoryDataSourceSpring中文文档

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

PropertiesSpring中文文档
YAMLSpring中文文档

spring.r2dbc.url=r2dbc:postgresql://localhost/test
spring.r2dbc.username=dbuser
spring.r2dbc.password=dbpass

spring:
  r2dbc:
    url: "r2dbc:postgresql://localhost/test"
    username: "dbuser"
    password: "dbpass"

您不需要指定驱动程序类名，因为 Spring Boot 从 R2DBC 的连接工厂发现中获取驱动程序。

至少应该提供 url。 URL 中指定的信息优先于单个属性，即、和池化选项。nameusernamepassword

“操作方法”部分包括有关如何初始化数据库的部分。

要自定义由创建的连接，即设置不希望（或不能）在中央数据库配置中配置的特定参数，可以使用 . 以下示例演示如何手动覆盖数据库端口，同时从应用程序配置中获取其余选项：ConnectionFactoryConnectionFactoryOptionsBuilderCustomizer@BeanSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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 连接选项：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

}

当 Bean 可用时，常规的 JDBC 自动配置将退出。如果要保留 JDBC 自动配置，并且愿意接受在响应式应用程序中使用阻塞 JDBC API 的风险，请在应用程序中添加一个类以重新启用它。ConnectionFactoryDataSourceDataSource@Import(DataSourceAutoConfiguration.class)@ConfigurationSpring中文文档

嵌入式数据库支持

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

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

如果在测试中使用此功能，您可能会注意到，无论使用的应用程序上下文数量如何，整个测试套件都会重复使用相同的数据库。如果要确保每个上下文都有一个单独的嵌入式数据库，则应设置为。spring.r2dbc.generate-unique-nametrueSpring中文文档

使用 DatabaseClient

Bean 是自动配置的，您可以将其直接配置到自己的 Bean 中，如以下示例所示：DatabaseClient@AutowireSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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 存储库是可以定义用于访问数据的接口。查询是根据方法名称自动创建的。例如，接口可以声明一种方法来查找给定状态中的所有城市。CityRepositoryfindAllByState(String state)Spring中文文档

对于更复杂的查询，您可以使用 Spring Data 的查询注释来注释您的方法。Spring中文文档

Spring Data 存储库通常从 Repository 或 CrudRepository 接口扩展。如果使用自动配置，则会在自动配置包中搜索存储库。Spring中文文档

以下示例显示了典型的 Spring Data 存储库接口定义：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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 参考文档。

您不需要指定驱动程序类名，因为 Spring Boot 从 R2DBC 的连接工厂发现中获取驱动程序。

至少应该提供 url。 URL 中指定的信息优先于单个属性，即、和池化选项。nameusernamepassword

“操作方法”部分包括有关如何初始化数据库的部分。

我们几乎没有触及Spring Data R2DBC的表面。有关完整的详细信息，请参阅 Spring Data R2DBC 参考文档。