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

配置数据源

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

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

嵌入式数据库支持

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

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

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

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

例如，典型的 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>
您需要依赖 on 才能自动配置嵌入式数据库。 在此示例中，它通过 传递方式拉入。spring-jdbcspring-boot-starter-data-jpa
无论出于何种原因，如果确实为嵌入式数据库配置了连接 URL，请注意确保禁用数据库的自动关闭功能。 如果使用 H2，则应使用 H2。 如果使用 HSQLDB，则应确保未使用它。 禁用数据库的自动关闭功能可以让 Spring Boot 控制数据库何时关闭，从而确保一旦不再需要访问数据库，它就会发生。DB_CLOSE_ON_EXIT=FALSEshutdown=true

连接到生产数据库

还可以使用池自动配置生产数据库连接。DataSource

数据源配置

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

  • Properties

  • YAML

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

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

  • Properties

  • 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 可用，我们将使用它。

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

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

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

  • 光CP

  • Tomcat 池化DataSource

  • 共享资源 DBCP2

  • 甲骨文 UCP &OracleDataSource

  • Spring Framework 的SimpleDriverDataSource

  • H2型JdbcDataSource

  • PostgreSQL的PGSimpleDataSource

  • 分子式：C3P0

与 JNDI 数据源的连接

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

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

  • Properties

  • YAML

spring.datasource.jndi-name=java:jboss/datasources/customers
spring:
  datasource:
    jndi-name: "java:jboss/datasources/customers"
有关更高级的示例，请参阅“操作方法”部分，通常用于完全控制 DataSource 的配置。
“操作方法”部分包括有关如何初始化数据库的部分。

如果在测试中使用此功能，您可能会注意到，无论使用的应用程序上下文数量如何，整个测试套件都会重复使用相同的数据库。 如果要确保每个上下文都有一个单独的嵌入式数据库，则应设置为 。spring.datasource.generate-unique-nametrue
您需要依赖 on 才能自动配置嵌入式数据库。 在此示例中，它通过 传递方式拉入。spring-jdbcspring-boot-starter-data-jpa
无论出于何种原因，如果确实为嵌入式数据库配置了连接 URL，请注意确保禁用数据库的自动关闭功能。 如果使用 H2，则应使用 H2。 如果使用 HSQLDB，则应确保未使用它。 禁用数据库的自动关闭功能可以让 Spring Boot 控制数据库何时关闭，从而确保一旦不再需要访问数据库，它就会发生。DB_CLOSE_ON_EXIT=FALSEshutdown=true
您至少应通过设置属性来指定 URL。 否则，Spring Boot 会尝试自动配置嵌入式数据库。spring.datasource.url
Spring Boot 可以从 URL 中推断出大多数数据库的 JDBC 驱动程序类。 如果需要指定特定类，可以使用该属性。spring.datasource.driver-class-name
对于要创建的池，我们需要能够验证有效的类是否可用，因此我们在执行任何操作之前都会检查它。 换句话说，如果设置了 ，那么该类必须是可加载的。DataSourceDriverspring.datasource.driver-class-name=com.mysql.jdbc.Driver
如果使用 或 “starters”，则会自动获得对 的依赖关系。spring-boot-starter-jdbcspring-boot-starter-data-jpaHikariCP

使用 JdbcTemplate

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

  • 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.*

  • Properties

  • YAML

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

使用 JdbcClient

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

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

}

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

JPA 和 Spring Data JPA

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

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

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

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

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

实体类

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

任何用 、 或 注释的类都将被考虑。 典型的实体类类似于以下示例：@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
	}

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

Spring Data JPA 存储库

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

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

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

使用延迟或延迟引导时，请确保在应用程序上下文引导阶段之后推迟对 JPA 基础架构的任何访问。 您可以使用它来调用任何需要 JPA 基础结构的初始化。 对于作为 Spring Bean 创建的 JPA 组件（如转换器），用于延迟依赖项的解析（如果有）。SmartInitializingSingletonObjectProvider
我们几乎没有触及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 数据库

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

  • Properties

  • YAML

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

  • Properties

  • YAML

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

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

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

在 View 中打开 EntityManager

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

我们在这里不赘述 JPA 或 Spring Data 的太多细节。 您可以按照 spring.io 中的“使用 JPA 访问数据”指南并阅读 Spring Data JPA 和 Hibernate 参考文档。
您可以使用注释自定义实体扫描位置。 请参阅“将@Entity定义与 Spring 配置分开”操作方法。@EntityScan
您可以使用 自定义要查找存储库的位置。@EnableJpaRepositories

使用延迟或延迟引导时，请确保在应用程序上下文引导阶段之后推迟对 JPA 基础架构的任何访问。 您可以使用它来调用任何需要 JPA 基础结构的初始化。 对于作为 Spring Bean 创建的 JPA 组件（如转换器），用于延迟依赖项的解析（如果有）。SmartInitializingSingletonObjectProvider
我们几乎没有触及Spring Data JPA的表面。 有关完整的详细信息，请参阅 Spring Data JPA 参考文档。
有关更多详细信息，请查看 Spring Data Envers 参考文档。
Hibernate 自己的内部属性名称（如果你碰巧记得更好的话）是 。 您可以使用以下方法将其与其他 Hibernate 本机属性一起设置（在将前缀添加到实体管理器之前将其剥离）。 以下行显示了为 Hibernate 设置 JPA 属性的示例：hibernate.hbm2ddl.autospring.jpa.properties.*

Spring 数据 JDBC

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

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

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

使用 H2 的 Web 控制台

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

如果您没有使用 Spring Boot 的开发人员工具，但仍想使用 H2 的控制台，则可以使用值 来配置该属性。spring.h2.console.enabledtrue
H2 控制台仅用于开发期间，因此应注意确保未在生产环境中将其设置为。spring.h2.console.enabledtrue

更改 H2 控制台的路径

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

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

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

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

  • 将标头设置为控制台的 On Responses。X-Frame-OptionsSAMEORIGIN

有关 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.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 一起使用。

代码生成

为了使用 jOOQ 类型安全查询，您需要从数据库模式生成 Java 类。 您可以按照 jOOQ 用户手册中的说明进行操作。 如果您使用插件并且还使用“父 POM”，则可以安全地省略插件的标签。 您还可以使用 Spring Boot 定义的版本变量（例如 ）来声明插件的数据库依赖关系。 以下列表显示了一个示例：jooq-codegen-mavenspring-boot-starter-parent<version>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 提供的 Fluent API 是通过接口启动的。 Spring Boot 自动将 a 配置为 Spring Bean 并将其连接到您的应用程序。 要使用 ，可以注入它，如以下示例所示：org.jooq.DSLContextDSLContextDataSourceDSLContext

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

然后，可以使用 来构造查询，如以下示例所示：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 Boot 将确定要用于数据源的 SQL 方言。 如果 Spring Boot 无法检测到方言，则使用 .spring.jooq.sql-dialectDEFAULT

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

自定义 jOOQ

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

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

jOOQ 手册倾向于使用一个名为 .createDSLContext
Spring Boot 只能自动配置开源版本的 jOOQ 支持的方言。

使用 R2DBC

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

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

  • Properties

  • YAML

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

}

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

嵌入式数据库支持

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

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

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

使用 DatabaseClient

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

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

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

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 参考文档。
您不需要指定驱动程序类名，因为 Spring Boot 从 R2DBC 的连接工厂发现中获取驱动程序。
至少应该提供 url。 URL 中指定的信息优先于单个属性，即 、 和池化选项。nameusernamepassword
“操作方法”部分包括有关如何初始化数据库的部分。

如果在测试中使用此功能，您可能会注意到，无论使用的应用程序上下文数量如何，整个测试套件都会重复使用相同的数据库。 如果要确保每个上下文都有一个单独的嵌入式数据库，则应设置为 。spring.r2dbc.generate-unique-nametrue
我们几乎没有触及Spring Data R2DBC的表面。有关完整的详细信息，请参阅 Spring Data R2DBC 参考文档。