数据

1. SQL 数据库

Spring Framework 为使用 SQL 数据库提供了广泛的支持，从直接 JDBC 访问到完整的“对象关系映射”技术，例如 Hibernate。Spring Data 提供了更高级别的功能：直接从接口创建实现，并使用约定从方法名称生成查询。JdbcTemplateRepositoryspring-doc.cn

1.1. 配置 DataSource

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

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

1.1.1. 嵌入式数据库支持

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

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

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

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

例如，典型的 POM 依赖项如下所示：spring-doc.cn

<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-jdbcspring-boot-starter-data-jpa

如果出于某种原因，您确实为嵌入式数据库配置了连接 URL，请注意确保禁用数据库的自动关闭。如果您使用 H2，则应使用 to 执行此操作。如果您使用 HSQLDB，则应确保未使用 HSQLDB。禁用数据库的自动关闭可以让 Spring Boot 控制数据库何时关闭，从而确保在不再需要访问数据库时进行关闭。DB_CLOSE_ON_EXIT=FALSEshutdown=true

1.1.2. 连接到生产数据库

也可以使用 pooling 自动配置 Production 数据库连接。DataSourcespring-doc.cn

1.1.3. DataSource 配置

DataSource 配置由中的外部配置属性控制。例如，您可以在：spring.datasource.*application.propertiesspring-doc.cn

性能

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

Yaml

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-doc.cn

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

性能

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

Yaml

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

这会将池设置为在没有可用连接的情况下等待 10000 毫秒，然后再引发异常，将最大连接数限制为 50 个，并在从池中借用连接之前验证连接。spring-doc.cn

1.1.4. 支持的连接池

Spring Boot 使用以下算法来选择特定实现：spring-doc.cn

我们更喜欢 HikariCP 的性能和并发性。如果 HikariCP 可用，我们总是会选择它。spring-doc.cn
否则，如果 Tomcat 池可用，我们将使用它。DataSourcespring-doc.cn
否则，如果 Commons DBCP2 可用，我们就会使用它。spring-doc.cn
如果 HikariCP、Tomcat 和 DBCP2 都不可用，并且 Oracle UCP 可用，则使用它。spring-doc.cn

如果使用或 “starters”，则会自动获得对 .spring-boot-starter-jdbcspring-boot-starter-data-jpaHikariCP

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

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

光CPspring-doc.cn
Tomcat 池Datasourcespring-doc.cn
共享 DBCP2spring-doc.cn
Oracle UCP 和OracleDataSourcespring-doc.cn
Spring 框架的SimpleDriverDataSourcespring-doc.cn
H2 系列JdbcDataSourcespring-doc.cn
PostgreSQL 数据库PGSimpleDataSourcespring-doc.cn
C3P0spring-doc.cn

1.1.5. 连接到 JNDI 数据源

如果将 Spring Boot 应用程序部署到 Application Server，则可能需要使用 Application Server 的内置功能来配置和管理 DataSource，并使用 JNDI 访问它。spring-doc.cn

该属性可用作、和属性的替代方法，以便从特定的 JNDI 位置访问。例如，以下部分显示了如何访问定义的 JBoss AS ：spring.datasource.jndi-namespring.datasource.urlspring.datasource.usernamespring.datasource.passwordDataSourceapplication.propertiesDataSourcespring-doc.cn

性能

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

Yaml

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

1.2. 使用 JdbcTemplate

Spring 的和 classes 是自动配置的，你可以将它们直接放入你自己的 bean 中，如以下示例所示：JdbcTemplateNamedParameterJdbcTemplate@Autowirespring-doc.cn

Java

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

}

Kotlin

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-doc.cn

性能

spring.jdbc.template.max-rows=500

Yaml

spring:
  jdbc:
    template:
      max-rows: 500

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

1.3. JPA 和 Spring Data JPA

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

Hibernate：最流行的 JPA 实现之一。spring-doc.cn
Spring Data JPA：帮助您实施基于 JPA 的存储库。spring-doc.cn
Spring ORM：来自 Spring 框架的核心 ORM 支持。spring-doc.cn

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

1.3.1. 实体类

传统上，JPA “Entity” 类是在文件中指定的。使用 Spring Boot 时，此文件不是必需的，而是使用 “Entity Scanning” 代替。默认情况下，将扫描自动配置包。persistence.xmlspring-doc.cn

考虑任何用、或注释的类。典型的实体类类似于以下示例：@Entity@Embeddable@MappedSuperclassspring-doc.cn

Java

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

}

Kotlin

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
    }

}

您可以使用注释自定义实体扫描位置。请参阅“howto.html”操作方法。@EntityScan

1.3.2. Spring Data JPA 存储库

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

对于更复杂的查询，您可以使用 Spring Data 的 Query 注释来注释您的方法。spring-doc.cn

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

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

以下示例显示了典型的 Spring Data 存储库接口定义：spring-doc.cn

Java

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

}

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

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

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

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

}

Spring Data JPA 存储库支持三种不同的引导模式：default、deferred 和 lazy。要启用延迟或延迟引导，请分别将属性设置为或。当使用延迟或延迟引导时，自动配置的将使用上下文的，如果有，作为引导执行程序。如果存在多个，则将使用 named 的那个。spring.data.jpa.repositories.bootstrap-modedeferredlazyEntityManagerFactoryBuilderAsyncTaskExecutorapplicationTaskExecutorspring-doc.cn

使用延迟或延迟引导时，请确保在应用程序上下文引导阶段之后推迟对 JPA 基础设施的任何访问。您可以使用来调用任何需要 JPA 基础设施的初始化。对于创建为 Spring bean 的 JPA 组件（例如转换器），请使用延迟依赖项的解析（如果有）。SmartInitializingSingletonObjectProviderspring-doc.cn

我们只是触及了 Spring Data JPA 的皮毛。有关完整详细信息，请参阅 Spring Data JPA 参考文档。

1.3.3. Spring Data Envers 存储库

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

要使用 Spring Data Envers，请确保您的存储库扩展自以下示例所示：RevisionRepositoryspring-doc.cn

Java

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

}

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

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

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

}

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

1.3.4. 创建和删除 JPA 数据库

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

性能

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

Yaml

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

Hibernate 自己的内部属性名称（如果你记得更清楚的话）是 . 你可以通过使用来设置它，以及其他 Hibernate 原生属性（在将它们添加到实体管理器之前，前缀会被去除）。以下行显示了为 Hibernate 设置 JPA 属性的示例：hibernate.hbm2ddl.autospring.jpa.properties.*

性能

spring.jpa.properties.hibernate[globally_quoted_identifiers]=true

Yaml

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

前面示例中的行将属性的值 of 传递给 Hibernate 实体管理器。truehibernate.globally_quoted_identifiersspring-doc.cn

默认情况下，DDL 执行（或验证）会延迟到开始。还有一个标志，但如果 Hibernate 自动配置处于活动状态，则不会使用它，因为设置更加细粒度。ApplicationContextspring.jpa.generate-ddlddl-autospring-doc.cn

1.3.5. 在 View 中打开 EntityManager

如果你正在运行一个 Web 应用程序， Spring Boot 默认注册OpenEntityManagerInViewInterceptor以应用“在视图中打开EntityManager”模式，以允许在 Web 视图中进行延迟加载。如果您不希望此行为，则应在 .spring.jpa.open-in-viewfalseapplication.propertiesspring-doc.cn

1.4. Spring Data JDBC

Spring Data 包括对 JDBC 的存储库支持，并将为上的方法自动生成 SQL。对于更高级的查询，提供了注释。CrudRepository@Queryspring-doc.cn

当必要的依赖项位于 Classpath 上时， Spring Boot 将自动配置 Spring Data 的 JDBC 存储库。它们可以通过对的单个依赖项添加到您的项目中。如有必要，您可以通过将 Comments 或子类添加到您的应用程序来控制 Spring Data JDBC 的配置。spring-boot-starter-data-jdbc@EnableJdbcRepositoriesAbstractJdbcConfigurationspring-doc.cn

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

1.5. 使用 H2 的 Web 控制台

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

您正在开发基于 servlet 的 Web 应用程序。spring-doc.cn
com.h2database:h2位于 Classpath 上。spring-doc.cn
您正在使用 Spring Boot 的开发人员工具。spring-doc.cn

如果您不使用 Spring Boot 的开发人员工具，但仍希望使用 H2 的控制台，则可以配置值为 .spring.h2.console.enabledtrue

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

1.5.1. 更改 H2 控制台的路径

默认情况下，控制台位于。您可以使用 property 自定义控制台的路径。/h2-consolespring.h2.console.pathspring-doc.cn

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

H2 控制台使用框架，因为它仅用于开发，所以不实施 CSRF 保护措施。如果您的应用程序使用 Spring Security，则需要将其配置为spring-doc.cn

对针对控制台的请求禁用 CSRF 保护，spring-doc.cn
将 Header （标头）设置为 On Responses （响应时）。X-Frame-OptionsSAMEORIGINspring-doc.cn

有关 CSRF 和标头 X-Frame-Options 的更多信息，请参见 Spring Security Reference Guide。spring-doc.cn

在简单的设置中，可以使用如下所示的设置：SecurityFilterChainspring-doc.cn

Java

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().sameOrigin());
        return http.build();
    }


}

Kotlin

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().disable()
            .headers().frameOptions().sameOrigin().and()
            .build()
    }


}

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

PathRequest.toH2Console()当控制台的路径已自定义时，也会返回正确的 Request Matcher。

1.6. 使用 jOOQ

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

1.6.1. 代码生成

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

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

1.6.2. 使用 DSLContext

jOOQ 提供的 Fluent API 是通过接口启动的。 Spring Boot 自动将 a 配置为 Spring Bean 并将其连接到您的 application 。要使用，您可以注入它，如以下示例所示：org.jooq.DSLContextDSLContextDataSourceDSLContextspring-doc.cn

Java

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


}

Kotlin

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

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


}

jOOQ 手册倾向于使用一个名为的变量来保存 .createDSLContext

然后，您可以使用来构建查询，如以下示例所示：DSLContextspring-doc.cn

Java

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

Kotlin

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

1.6.3. jOOQ SQL 方言

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

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

1.6.4. 自定义 jOOQ

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

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

1.7. 使用 R2DBC

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

ConnectionFactory配置由中的外部配置属性控制。例如，您可以在：spring.r2dbc.*application.propertiesspring-doc.cn

性能

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

Yaml

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

你不需要指定驱动程序类名，因为 Spring Boot 从 R2DBC 的 Connection Factory 发现中获取驱动程序。

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

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

要自定义由创建的连接，即设置您不希望（或不能）在中央数据库配置中配置的特定参数，您可以使用 . 以下示例显示了如何手动覆盖数据库端口，而其余选项则从应用程序配置中获取：ConnectionFactoryConnectionFactoryOptionsBuilderCustomizer@Beanspring-doc.cn

Java

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

}

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)
class MyR2dbcConfiguration {

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

}

以下示例显示如何设置一些 PostgreSQL 连接选项：spring-doc.cn

Java

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

}

Kotlin

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-doc.cn

1.7.1. 嵌入式数据库支持

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

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

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

1.7.2. 使用 DatabaseClient

bean 是自动配置的，你可以直接将其放入自己的 bean 中，如以下示例所示：DatabaseClient@Autowirespring-doc.cn

Java

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

}

Kotlin

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

}

1.7.3. Spring Data R2DBC 存储库

Spring Data R2DBC 存储库是您可以定义以访问数据的接口。查询是根据您的方法名称自动创建的。例如，接口可以声明一个方法来查找给定状态中的所有城市。CityRepositoryfindAllByState(String state)spring-doc.cn

对于更复杂的查询，您可以使用 Spring Data 的 Query 注释来注释您的方法。spring-doc.cn

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

以下示例显示了典型的 Spring Data 存储库接口定义：spring-doc.cn

Java

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

}

Kotlin

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

2. 使用 NoSQL 技术

Spring Data 提供了其他项目，可帮助您访问各种 NoSQL 技术，包括：spring-doc.cn

其中，Spring Boot 为 Cassandra、Couchbase、Elasticsearch、LDAP、MongoDB、Neo4J 和 Redis 提供了自动配置。此外，Spring Boot for Apache Geode 还提供 Apache Geode 的自动配置。您可以使用其他项目，但必须自己配置它们。请参阅 spring.io/projects/spring-data 中的相应参考文档。spring-doc.cn

Spring Boot 还为 InfluxDB 客户端提供了自动配置。spring-doc.cn

2.1. Redis

Redis 是一个缓存、消息代理和功能丰富的键值存储。 Spring Boot 为 Lettuce 和 Jedis 客户端库以及 Spring Data Redis 提供的抽象提供了基本的自动配置。spring-doc.cn

有一个 “Starter” 用于以方便的方式收集依赖项。默认情况下，它使用 Lettuce。该Starters可以处理传统和响应式应用程序。spring-boot-starter-data-redisspring-doc.cn

我们还提供了一个 “Starter” ，以便与其他具有反应式支持的 store 保持一致。spring-boot-starter-data-redis-reactive

2.1.1. 连接到 Redis

您可以像注入任何其他 Spring Bean 一样注入自动配置的、或 vanilla 实例。下面的清单显示了这种 bean 的一个示例：RedisConnectionFactoryStringRedisTemplateRedisTemplatespring-doc.cn

Java

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final StringRedisTemplate template;

    public MyBean(StringRedisTemplate template) {
        this.template = template;
    }

    // ...

    public Boolean someMethod() {
        return this.template.hasKey("spring");
    }

}

Kotlin

import org.springframework.data.redis.core.StringRedisTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: StringRedisTemplate) {

    // ...

    fun someMethod(): Boolean {
        return template.hasKey("spring")
    }

}

默认情况下，实例尝试连接到位于的 Redis 服务器。您可以使用 properties 指定自定义连接详细信息，如以下示例所示：localhost:6379spring.data.redis.*spring-doc.cn

性能

spring.data.redis.host=localhost
spring.data.redis.port=6379
spring.data.redis.database=0
spring.data.redis.username=user
spring.data.redis.password=secret

Yaml

spring:
  data:
    redis:
      host: "localhost"
      port: 6379
      database: 0
      username: "user"
      password: "secret"

您还可以注册任意数量的 bean 来实现更高级的自定义。也可以使用进行自定义。如果您使用 Jedis，也可以使用。或者，您可以注册，类型的 bean 或完全控制配置。LettuceClientConfigurationBuilderCustomizerClientResourcesClientResourcesBuilderCustomizerJedisClientConfigurationBuilderCustomizerRedisStandaloneConfigurationRedisSentinelConfigurationRedisClusterConfiguration

如果添加自己的任何自动配置类型，它将替换默认值（除非，当排除基于 bean 名称，而不是其类型时）。@BeanRedisTemplateredisTemplatespring-doc.cn

默认情况下，如果池连接工厂在 Classpath 上，则会自动配置。commons-pool2spring-doc.cn

2.2. MongoDB 数据库

MongoDB 是一个开源 NoSQL 文档数据库，它使用类似 JSON 的架构，而不是传统的基于表的关系数据。 Spring Boot 为使用 MongoDB 提供了多种便利，包括“Starters”。spring-boot-starter-data-mongodbspring-boot-starter-data-mongodb-reactivespring-doc.cn

2.2.1. 连接到 MongoDB 数据库

要访问 MongoDB 数据库，您可以注入自动配置的 . 默认情况下，实例尝试连接到位于的 MongoDB 服务器。以下示例显示如何连接到 MongoDB 数据库：org.springframework.data.mongodb.MongoDatabaseFactorymongodb://localhost/testspring-doc.cn

Java

import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final MongoDatabaseFactory mongo;

    public MyBean(MongoDatabaseFactory mongo) {
        this.mongo = mongo;
    }

    // ...

    public MongoCollection<Document> someMethod() {
        MongoDatabase db = this.mongo.getMongoDatabase();
        return db.getCollection("users");
    }

}

Kotlin

import com.mongodb.client.MongoCollection
import org.bson.Document
import org.springframework.data.mongodb.MongoDatabaseFactory
import org.springframework.stereotype.Component

@Component
class MyBean(private val mongo: MongoDatabaseFactory) {

    // ...

    fun someMethod(): MongoCollection<Document> {
        val db = mongo.mongoDatabase
        return db.getCollection("users")
    }

}

如果您定义了自己的，它将用于自动配置合适的 .MongoClientMongoDatabaseFactoryspring-doc.cn

auto-configured 是使用 bean 创建的。如果您已定义自己的，则无需修改即可使用它，并且将忽略这些属性。否则，将自动配置 a 并将应用属性。在任何一种情况下，您都可以声明一个或多个 bean 来微调配置。每个都将按顺序调用，其中用于构建 .MongoClientMongoClientSettingsMongoClientSettingsspring.data.mongodbMongoClientSettingsspring.data.mongodbMongoClientSettingsBuilderCustomizerMongoClientSettingsMongoClientSettings.BuilderMongoClientSettingsspring-doc.cn

您可以设置该属性以更改 URL 并配置其他设置，例如副本集，如以下示例所示：spring.data.mongodb.urispring-doc.cn

性能

spring.data.mongodb.uri=mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test

Yaml

spring:
  data:
    mongodb:
      uri: "mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test"

或者，您可以使用 discrete 属性指定连接详细信息。例如，您可以在：application.propertiesspring-doc.cn

性能

spring.data.mongodb.host=mongoserver1.example.com
spring.data.mongodb.port=27017
spring.data.mongodb.additional-hosts[0]=mongoserver2.example.com:23456
spring.data.mongodb.database=test
spring.data.mongodb.username=user
spring.data.mongodb.password=secret

Yaml

spring:
  data:
    mongodb:
      host: "mongoserver1.example.com"
      port: 27017
      additional-hosts:
      - "mongoserver2.example.com:23456"
      database: "test"
      username: "user"
      password: "secret"

如果未指定，则使用默认值 of。您可以从前面显示的示例中删除此行。spring.data.mongodb.port27017spring-doc.cn

您还可以使用语法将端口指定为主机地址的一部分。如果需要更改条目的端口，则应使用此格式。host:portadditional-hostsspring-doc.cn

如果您不使用 Spring Data MongoDB，则可以注入 bean 而不是使用。如果要完全控制建立 MongoDB 连接，还可以声明自己的 bean 或 bean。MongoClientMongoDatabaseFactoryMongoDatabaseFactoryMongoClient

如果您使用的是反应式驱动程序，则 SSL 需要 Netty。如果 Netty 可用并且要使用的工厂尚未自定义，则自动配置会自动配置此工厂。

2.2.2. MongoTemplate

Spring Data MongoDB 提供了一个 MongoTemplate 类，该类在设计上与 Spring 的类非常相似。与Spring Boot一样，Spring Boot 会自动配置一个 bean 以注入模板，如下所示：JdbcTemplateJdbcTemplatespring-doc.cn

Java

import com.mongodb.client.MongoCollection;
import org.bson.Document;

import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final MongoTemplate mongoTemplate;

    public MyBean(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    // ...

    public MongoCollection<Document> someMethod() {
        return this.mongoTemplate.getCollection("users");
    }

}

Kotlin

import com.mongodb.client.MongoCollection
import org.bson.Document
import org.springframework.data.mongodb.core.MongoTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val mongoTemplate: MongoTemplate) {

    // ...

    fun someMethod(): MongoCollection<Document> {
        return mongoTemplate.getCollection("users")
    }

}

有关完整详细信息，请参阅 MongoOperations Javadoc。spring-doc.cn

2.2.3. Spring Data MongoDB 存储库

Spring Data 包括对 MongoDB 的存储库支持。与前面讨论的 JPA 存储库一样，基本原则是查询是根据方法名称自动构造的。spring-doc.cn

事实上，Spring Data JPA 和 Spring Data MongoDB 共享相同的通用基础设施。您可以采用前面的 JPA 示例，假设它现在是MongoDB数据类而不是 JPA，它的工作方式相同，如以下示例所示：City@Entityspring-doc.cn

Java

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

}

Kotlin

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

通过扫描找到存储库和文档。默认情况下，将扫描自动配置包。您可以分别使用和自定义位置以查找存储库和文档。@EnableMongoRepositories@EntityScanspring-doc.cn

有关 Spring Data MongoDB 的完整详细信息，包括其丰富的对象映射技术，请参阅其参考文档。

2.3. Neo4j

Neo4j 是一个开源的 NoSQL 图形数据库，它使用由第一类关系连接的节点的丰富数据模型，与传统的 RDBMS 方法相比，它更适合连接的大数据。 Spring Boot 为使用 Neo4j 提供了多种便利，包括“Starter”。spring-boot-starter-data-neo4jspring-doc.cn

2.3.1. 连接到 Neo4j 数据库

要访问 Neo4j 服务器，您可以注入自动配置的 . 默认情况下，实例尝试使用 Bolt 协议连接到 Neo4j 服务器。下面的示例展示了如何注入一个 Neo4j，它允许你访问一个：org.neo4j.driver.Driverlocalhost:7687DriverSessionspring-doc.cn

Java

import org.neo4j.driver.Driver;
import org.neo4j.driver.Session;
import org.neo4j.driver.Values;

import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final Driver driver;

    public MyBean(Driver driver) {
        this.driver = driver;
    }

    // ...

    public String someMethod(String message) {
        try (Session session = this.driver.session()) {
            return session.executeWrite(
                    (transaction) -> transaction
                        .run("CREATE (a:Greeting) SET a.message = $message RETURN a.message + ', from node ' + id(a)",
                                Values.parameters("message", message))
                        .single()
                        .get(0)
                        .asString());
        }
    }

}

Kotlin

import org.neo4j.driver.*
import org.springframework.stereotype.Component

@Component
class MyBean(private val driver: Driver) {

    // ...

    fun someMethod(message: String?): String {
        driver.session().use { session ->
            return@someMethod session.executeWrite { transaction: TransactionContext ->
                transaction
                    .run(
                        "CREATE (a:Greeting) SET a.message = \$message RETURN a.message + ', from node ' + id(a)",
                        Values.parameters("message", message)
                    )
                    .single()[0].asString()
            }
        }
    }

}

您可以使用属性配置驱动程序的各个方面。以下示例显示如何配置要使用的 uri 和凭证：spring.neo4j.*spring-doc.cn

性能

spring.neo4j.uri=bolt://my-server:7687
spring.neo4j.authentication.username=neo4j
spring.neo4j.authentication.password=secret

Yaml

spring:
  neo4j:
    uri: "bolt://my-server:7687"
    authentication:
      username: "neo4j"
      password: "secret"

自动配置的是使用创建的。要微调其配置，请声明一个或多个 bean。每个都将按顺序调用，其中用于构建 .DriverConfigBuilderConfigBuilderCustomizerConfigBuilderDriverspring-doc.cn

2.3.2. Spring Data Neo4j 存储库

Spring Data 包括对 Neo4j 的存储库支持。有关 Spring Data Neo4j 的完整详细信息，请参阅参考文档。spring-doc.cn

与许多其他 Spring Data 模块一样，Spring Data Neo4j 与 Spring Data JPA 共享公共基础设施。你可以采用前面的 JPA 示例，并将其定义为 Spring Data Neo4j 而不是 JPA，并且存储库抽象的工作方式相同，如以下示例所示：City@Node@Entityspring-doc.cn

Java

import java.util.Optional;

import org.springframework.data.neo4j.repository.Neo4jRepository;

public interface CityRepository extends Neo4jRepository<City, Long> {

    Optional<City> findOneByNameAndState(String name, String state);

}

Kotlin

import org.springframework.data.neo4j.repository.Neo4jRepository
import java.util.Optional

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

    fun findOneByNameAndState(name: String?, state: String?): Optional<City?>?

}

“Starter” 启用存储库支持以及事务管理。 Spring Boot 使用 or bean 支持经典和反应式 Neo4j 存储库。当 Project Reactor 在 Classpath 上可用时，反应式样式也会自动配置。spring-boot-starter-data-neo4jNeo4jTemplateReactiveNeo4jTemplatespring-doc.cn

通过扫描找到存储库和实体。默认情况下，将扫描自动配置包。您可以分别使用和自定义位置以查找存储库和实体。@EnableNeo4jRepositories@EntityScanspring-doc.cn

在使用 reactive 样式的应用程序中，a 不是自动配置的。要启用事务管理，必须在您的配置中定义以下 bean：ReactiveTransactionManagerspring-doc.cn

Java

import org.neo4j.driver.Driver;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider;
import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager;

@Configuration(proxyBeanMethods = false)
public class MyNeo4jConfiguration {

    @Bean
    public ReactiveNeo4jTransactionManager reactiveTransactionManager(Driver driver,
            ReactiveDatabaseSelectionProvider databaseNameProvider) {
        return new ReactiveNeo4jTransactionManager(driver, databaseNameProvider);
    }

}

Kotlin

import org.neo4j.driver.Driver
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider
import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager

@Configuration(proxyBeanMethods = false)
class MyNeo4jConfiguration {

    @Bean
    fun reactiveTransactionManager(driver: Driver,
            databaseNameProvider: ReactiveDatabaseSelectionProvider): ReactiveNeo4jTransactionManager {
        return ReactiveNeo4jTransactionManager(driver, databaseNameProvider)
    }
}

2.4. Elasticsearch

Elasticsearch 是一个开源的分布式 RESTful 搜索和分析引擎。 Spring Boot 为 Elasticsearch 客户端提供了基本的自动配置。spring-doc.cn

Spring Boot 支持多个客户端：spring-doc.cn

官方的低级 REST 客户端spring-doc.cn
官方 Java API 客户端spring-doc.cn
由 Spring Data Elasticsearch 提供ReactiveElasticsearchClientspring-doc.cn

Spring Boot 提供了一个专用的 “Starter” 。spring-boot-starter-data-elasticsearchspring-doc.cn

2.4.1. 使用 REST 客户端连接到 Elasticsearch

Elasticsearch 提供了两个不同的 REST 客户端，您可以使用它们来查询集群：模块中的低级客户端和模块中的 Java API 客户端。此外， Spring Boot 还为来自模块的反应式 Client 端提供支持。默认情况下，客户端将以为目标。您可以使用 properties 来进一步调整客户端的配置方式，如以下示例所示：org.elasticsearch.client:elasticsearch-rest-clientco.elastic.clients:elasticsearch-javaorg.springframework.data:spring-data-elasticsearchlocalhost:9200spring.elasticsearch.*spring-doc.cn

性能

spring.elasticsearch.uris=https://search.example.com:9200
spring.elasticsearch.socket-timeout=10s
spring.elasticsearch.username=user
spring.elasticsearch.password=secret

Yaml

spring:
  elasticsearch:
    uris: "https://search.example.com:9200"
    socket-timeout: "10s"
    username: "user"
    password: "secret"

使用 RestClient 连接到 Elasticsearch

如果你在 Classpath 上，Spring Boot 将自动配置并注册一个 bean。除了前面描述的属性之外，要微调还可以注册任意数量的 bean，这些 bean 实现更高级的自定义。要完全控制客户端的配置，请定义一个 bean。elasticsearch-rest-clientRestClientRestClientRestClientBuilderCustomizerRestClientBuilderspring-doc.cn

此外，如果在 Classpath 上，则 a 会自动配置为从正在运行的 Elasticsearch 集群中自动发现节点并在 bean 上设置它们。您可以进一步调整配置方式，如以下示例所示：elasticsearch-rest-client-snifferSnifferRestClientSnifferspring-doc.cn

性能

spring.elasticsearch.restclient.sniffer.interval=10m
spring.elasticsearch.restclient.sniffer.delay-after-failure=30s

Yaml

spring:
  elasticsearch:
    restclient:
      sniffer:
        interval: "10m"
        delay-after-failure: "30s"

使用 ElasticsearchClient 连接到 Elasticsearch

如果你在 Classpath 上，Spring Boot 将自动配置并注册一个 bean。co.elastic.clients:elasticsearch-javaElasticsearchClientspring-doc.cn

使用依赖于前面描述的 . 因此，前面描述的属性可用于配置 . 此外，您可以定义一个 bean 以进一步控制传输的行为。ElasticsearchClientRestClientElasticsearchClientTransportOptionsspring-doc.cn

使用 ReactiveElasticsearchClient 连接到 Elasticsearch

Spring Data Elasticsearch 用于以反应方式查询 Elasticsearch 实例。如果您在类路径上有 Spring Data Elasticsearch 和 Reactor，则 Spring Boot 将自动配置并注册一个 .ReactiveElasticsearchClientReactiveElasticsearchClientspring-doc.cn

使用依赖于前面描述的 . 因此，前面描述的属性可用于配置 . 此外，您可以定义一个 bean 以进一步控制传输的行为。ReactiveElasticsearchclientRestClientReactiveElasticsearchClientTransportOptionsspring-doc.cn

2.4.2. 使用 Spring Data 连接到 Elasticsearch

要连接到 Elasticsearch，必须定义一个 Bean，由 Spring Boot 自动配置或由应用程序手动提供（请参阅前面的部分）。有了这个配置，就可以像任何其他 Spring bean 一样注入 an，如以下示例所示：ElasticsearchClientElasticsearchTemplatespring-doc.cn

Java

import org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final ElasticsearchTemplate template;

    public MyBean(ElasticsearchTemplate template) {
        this.template = template;
    }

    // ...

    public boolean someMethod(String id) {
        return this.template.exists(id, User.class);
    }

}

Kotlin

import org.springframework.stereotype.Component

@Component
class MyBean(private val template: org.springframework.data.elasticsearch.client.erhlc.ElasticsearchRestTemplate ) {

    // ...

    fun someMethod(id: String): Boolean {
        return template.exists(id, User::class.java)
    }

}

在存在和 Reactor 的情况下， Spring Boot 还可以自动配置ReactiveElasticsearchClient和作为 bean。它们是其他 REST 客户端的反应式等效项。spring-data-elasticsearchReactiveElasticsearchTemplatespring-doc.cn

2.4.3. Spring Data Elasticsearch 存储库

Spring Data 包括对 Elasticsearch 的存储库支持。与前面讨论的 JPA 存储库一样，基本原则是根据方法名称自动为您构建查询。spring-doc.cn

事实上，Spring Data JPA 和 Spring Data Elasticsearch 共享相同的通用基础架构。您可以采用前面的 JPA 示例，假设它现在是 Elasticsearch 类而不是 JPA，它的工作方式相同。City@Document@Entityspring-doc.cn

通过扫描找到存储库和文档。默认情况下，将扫描自动配置包。您可以分别使用和自定义位置以查找存储库和文档。@EnableElasticsearchRepositories@EntityScanspring-doc.cn

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

Spring Boot 使用 or bean 支持经典和反应式 Elasticsearch 存储库。如果存在所需的依赖项，这些 bean 很可能是由 Spring Boot 自动配置的。ElasticsearchRestTemplateReactiveElasticsearchTemplatespring-doc.cn

如果您希望使用自己的模板来支持 Elasticsearch 存储库，则可以添加自己的或，只要它名为 . 这同样适用于和，具有 bean 名称。ElasticsearchRestTemplateElasticsearchOperations@Bean"elasticsearchTemplate"ReactiveElasticsearchTemplateReactiveElasticsearchOperations"reactiveElasticsearchTemplate"spring-doc.cn

您可以选择使用以下属性禁用存储库支持：spring-doc.cn

性能

spring.data.elasticsearch.repositories.enabled=false

Yaml

spring:
  data:
    elasticsearch:
      repositories:
        enabled: false

2.5. Cassandra

Cassandra 是一个开源的分布式数据库管理系统，旨在处理跨许多商用服务器的大量数据。 Spring Boot 为 Cassandra 提供了自动配置，以及 Spring Data Cassandra 提供的抽象。有一个 “Starter” 用于以方便的方式收集依赖项。spring-boot-starter-data-cassandraspring-doc.cn

2.5.1. 连接到 Cassandra

您可以像注入任何其他 Spring Bean 一样注入自动配置的实例或 Cassandra 实例。这些属性可用于自定义连接。通常，您需要提供和 local datacenter 名称，如以下示例所示：CassandraTemplateCqlSessionspring.cassandra.*keyspace-namecontact-pointsspring-doc.cn

性能

spring.cassandra.keyspace-name=mykeyspace
spring.cassandra.contact-points=cassandrahost1:9042,cassandrahost2:9042
spring.cassandra.local-datacenter=datacenter1

Yaml

spring:
  cassandra:
    keyspace-name: "mykeyspace"
    contact-points: "cassandrahost1:9042,cassandrahost2:9042"
    local-datacenter: "datacenter1"

如果所有联系点的端口都相同，则可以使用快捷方式，并且仅指定主机名，如以下示例所示：spring-doc.cn

性能

spring.cassandra.keyspace-name=mykeyspace
spring.cassandra.contact-points=cassandrahost1,cassandrahost2
spring.cassandra.local-datacenter=datacenter1

Yaml

spring:
  cassandra:
    keyspace-name: "mykeyspace"
    contact-points: "cassandrahost1,cassandrahost2"
    local-datacenter: "datacenter1"

这两个示例与默认为的端口相同。如果需要配置端口，请使用。9042spring.cassandra.port

Cassandra 驱动程序有自己的配置基础结构，该基础结构在 Classpath 的根目录中加载。application.confspring-doc.cn

默认情况下，Spring Boot 不会查找此类文件，但可以使用 . 如果配置文件中同时存在属性，则值 in 优先。spring.cassandra.configspring.cassandra.*spring.cassandra.*spring-doc.cn

对于更高级的驱动程序自定义，您可以注册任意数量的实现 bean 。可以使用 .DriverConfigLoaderBuilderCustomizerCqlSessionCqlSessionBuilderCustomizerspring-doc.cn

如果你用来创建多个 bean，请记住 builder 是可变的，所以确保为每个会话注入一个新的副本。CqlSessionBuilderCqlSession

下面的代码清单显示了如何注入 Cassandra bean：spring-doc.cn

Java

import org.springframework.data.cassandra.core.CassandraTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final CassandraTemplate template;

    public MyBean(CassandraTemplate template) {
        this.template = template;
    }

    // ...

    public long someMethod() {
        return this.template.count(User.class);
    }

}

Kotlin

import org.springframework.data.cassandra.core.CassandraTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: CassandraTemplate) {

    // ...

    fun someMethod(): Long {
        return template.count(User::class.java)
    }

}

如果添加自己的 type ，它将替换 default。@BeanCassandraTemplatespring-doc.cn

2.5.2. Spring Data Cassandra 存储库

Spring Data 包括对 Cassandra 的基本存储库支持。目前，这比前面讨论的 JPA 存储库更有限，并且需要带注释的 finder 方法。@Queryspring-doc.cn

通过扫描找到存储库和实体。默认情况下，将扫描自动配置包。您可以分别使用和自定义位置以查找存储库和实体。@EnableCassandraRepositories@EntityScanspring-doc.cn

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

2.6. Couchbase

Couchbase 是一个开源、分布式、多模型、面向文档的 NoSQL 数据库，针对交互式应用程序进行了优化。 Spring Boot 为 Couchbase 提供了自动配置，并且 Spring Data Couchbase 提供了它之上的抽象。有和 “Starters” 用于以方便的方式收集依赖项。spring-boot-starter-data-couchbasespring-boot-starter-data-couchbase-reactivespring-doc.cn

2.6.1. 连接到 Couchbase

您可以通过添加 Couchbase SDK 和一些配置来获得 A。这些属性可用于自定义连接。通常，您需要提供连接字符串、用户名和密码，如以下示例所示：Clusterspring.couchbase.*spring-doc.cn

性能

spring.couchbase.connection-string=couchbase://192.168.1.123
spring.couchbase.username=user
spring.couchbase.password=secret

Yaml

spring:
  couchbase:
    connection-string: "couchbase://192.168.1.123"
    username: "user"
    password: "secret"

还可以自定义某些设置。例如，以下配置更改了打开新 API 的超时并启用 SSL 支持：ClusterEnvironmentBucketspring-doc.cn

性能

spring.couchbase.env.timeouts.connect=3s
spring.couchbase.env.ssl.key-store=/location/of/keystore.jks
spring.couchbase.env.ssl.key-store-password=secret

Yaml

spring:
  couchbase:
    env:
      timeouts:
        connect: "3s"
      ssl:
        key-store: "/location/of/keystore.jks"
        key-store-password: "secret"

检查属性以了解更多详细信息。为了获得更多控制，可以使用一个或多个 bean。spring.couchbase.env.*ClusterEnvironmentBuilderCustomizer

2.6.2. Spring Data Couchbase 存储库

Spring Data 包括对 Couchbase 的存储库支持。spring-doc.cn

通过扫描找到存储库和文档。默认情况下，将扫描自动配置包。您可以分别使用和自定义位置以查找存储库和文档。@EnableCouchbaseRepositories@EntityScanspring-doc.cn

有关 Spring Data Couchbase 的完整详细信息，请参阅参考文档。spring-doc.cn

只要 Bean 可用，就可以像使用任何其他 Spring Bean 一样注入自动配置的实例。如上所述，当 a 可用并且已指定存储桶名称时，会发生这种情况：CouchbaseTemplateCouchbaseClientFactoryClusterspring-doc.cn

性能

spring.data.couchbase.bucket-name=my-bucket

Yaml

spring:
  data:
    couchbase:
      bucket-name: "my-bucket"

以下示例展示了如何注入 bean：CouchbaseTemplatespring-doc.cn

Java

import org.springframework.data.couchbase.core.CouchbaseTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final CouchbaseTemplate template;

    public MyBean(CouchbaseTemplate template) {
        this.template = template;
    }

    // ...

    public String someMethod() {
        return this.template.getBucketName();
    }

}

Kotlin

import org.springframework.data.couchbase.core.CouchbaseTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: CouchbaseTemplate) {

    // ...

    fun someMethod(): String {
        return template.bucketName
    }

}

您可以在自己的配置中定义一些 bean 来覆盖 auto-configuration 提供的 bean：spring-doc.cn

名称为 .CouchbaseMappingContext@BeancouchbaseMappingContextspring-doc.cn
名称为 .CustomConversions@BeancouchbaseCustomConversionsspring-doc.cn
名称为 .CouchbaseTemplate@BeancouchbaseTemplatespring-doc.cn

为避免在您自己的配置中对这些名称进行硬编码，您可以重用 Spring Data Couchbase 提供的。例如，您可以自定义要使用的转换器，如下所示：BeanNamesspring-doc.cn

Java

import org.assertj.core.util.Arrays;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.couchbase.config.BeanNames;
import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions;

@Configuration(proxyBeanMethods = false)
public class MyCouchbaseConfiguration {

    @Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
    public CouchbaseCustomConversions myCustomConversions() {
        return new CouchbaseCustomConversions(Arrays.asList(new MyConverter()));
    }

}

Kotlin

import org.assertj.core.util.Arrays
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.couchbase.config.BeanNames
import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions

@Configuration(proxyBeanMethods = false)
class MyCouchbaseConfiguration {

    @Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
    fun myCustomConversions(): CouchbaseCustomConversions {
        return CouchbaseCustomConversions(Arrays.asList(MyConverter()))
    }

}

2.7. LDAP 协议

LDAP（轻量级目录访问协议）是一种开放的、供应商中立的行业标准应用协议，用于通过 IP 网络访问和维护分布式目录信息服务。 Spring Boot 为任何兼容的 LDAP 服务器提供自动配置，并支持来自 UnboundID 的嵌入式内存 LDAP 服务器。spring-doc.cn

LDAP 抽象由 Spring Data LDAP 提供。有一个 “Starter” 用于以方便的方式收集依赖项。spring-boot-starter-data-ldapspring-doc.cn

2.7.1. 连接到 LDAP 服务器

要连接到 LDAP 服务器，请确保声明对“Starter”的依赖项，或者在 application.properties 中声明服务器的 URL，如以下示例所示：spring-boot-starter-data-ldapspring-ldap-corespring-doc.cn

性能

spring.ldap.urls=ldap://myserver:1235
spring.ldap.username=admin
spring.ldap.password=secret

Yaml

spring:
  ldap:
    urls: "ldap://myserver:1235"
    username: "admin"
    password: "secret"

如果需要自定义连接设置，可以使用和属性。spring.ldap.basespring.ldap.base-environmentspring-doc.cn

An 根据这些设置进行自动配置。如果 bean 可用，则它与 auto-configured 相关联。如果需要自定义它，例如使用，您仍然可以注入自动配置的 . 确保标记您的自定义 as，以便自动配置的 AUS 使用它。LdapContextSourceDirContextAuthenticationStrategyLdapContextSourcePooledContextSourceLdapContextSourceContextSource@PrimaryLdapTemplatespring-doc.cn

2.7.2. Spring Data LDAP 存储库

Spring Data 包括对 LDAP 的存储库支持。spring-doc.cn

通过扫描找到存储库和文档。默认情况下，将扫描自动配置包。您可以分别使用和自定义位置以查找存储库和文档。@EnableLdapRepositories@EntityScanspring-doc.cn

有关 Spring Data LDAP 的完整详细信息，请参阅参考文档。spring-doc.cn

你也可以像注入任何其他 Spring Bean 一样注入自动配置的实例，如以下示例所示：LdapTemplatespring-doc.cn

Java

import java.util.List;

import org.springframework.ldap.core.LdapTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final LdapTemplate template;

    public MyBean(LdapTemplate template) {
        this.template = template;
    }

    // ...

    public List<User> someMethod() {
        return this.template.findAll(User.class);
    }

}

Kotlin

import org.springframework.ldap.core.LdapTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: LdapTemplate) {

    // ...

    fun someMethod(): List<User> {
        return template.findAll(User::class.java)
    }

}

2.7.3. 嵌入式内存 LDAP 服务器

出于测试目的， Spring Boot 支持从 UnboundID 自动配置内存中的 LDAP 服务器。要配置服务器，请添加依赖项并声明属性，如下所示：com.unboundid:unboundid-ldapsdkspring.ldap.embedded.base-dnspring-doc.cn

性能

spring.ldap.embedded.base-dn=dc=spring,dc=io

Yaml

spring:
  ldap:
    embedded:
      base-dn: "dc=spring,dc=io"

可以定义多个 base-dn 值，但是，由于专有名称通常包含逗号，因此必须使用正确的表示法来定义它们。spring-doc.cn

在 yaml 文件中，您可以使用 yaml 列表表示法。在属性文件中，必须将索引作为属性名称的一部分包含在内：spring-doc.cn

性能

spring.ldap.embedded.base-dn[0]=dc=spring,dc=io
spring.ldap.embedded.base-dn[1]=dc=vmware,dc=com

Yaml

spring.ldap.embedded.base-dn:
  - "dc=spring,dc=io"
  - "dc=vmware,dc=com"

默认情况下，服务器在随机端口上启动并触发常规 LDAP 支持。无需指定属性。spring.ldap.urlsspring-doc.cn

如果您的 Classpath 上有一个文件，则使用它来初始化服务器。如果要从其他资源加载初始化脚本，还可以使用 property .schema.ldifspring.ldap.embedded.ldifspring-doc.cn

默认情况下，使用标准架构来验证文件。您可以通过设置该属性来完全关闭验证。如果您有自定义属性，则可以使用来定义自定义属性类型或对象类。LDIFspring.ldap.embedded.validation.enabledspring.ldap.embedded.validation.schemaspring-doc.cn

2.8. InfluxDB 数据库

InfluxDB 是一个开源时间序列数据库，针对操作监控、应用程序指标、物联网传感器数据和实时分析等领域的时间序列数据的快速、高可用性存储和检索进行了优化。spring-doc.cn

2.8.1. 连接到 InfluxDB

Spring Boot 会自动配置一个实例，前提是客户端位于 Classpath 上并且设置了数据库的 URL，如以下示例所示：InfluxDBinfluxdb-javaspring-doc.cn

性能

spring.influx.url=https://172.0.0.1:8086

Yaml

spring:
  influx:
    url: "https://172.0.0.1:8086"

如果与 InfluxDB 的连接需要用户和密码，您可以相应地设置 and 属性。spring.influx.userspring.influx.passwordspring-doc.cn

InfluxDB 依赖于 OkHttp。如果需要在后台调整 http 客户端的使用，则可以注册一个 bean。InfluxDBInfluxDbOkHttpClientBuilderProviderspring-doc.cn

如果需要对配置进行更多控制，请考虑注册 Bean。InfluxDbCustomizerspring-doc.cn

3. 下一步要读什么

现在，您应该对如何将 Spring Boot 与各种数据技术结合使用有所了解。从这里，您可以了解 Spring Boot 对各种消息传递技术的支持，以及如何在您的应用程序中启用它们。spring-doc.cn