Spring Boot 集成了多种数据技术，包括 SQL 和 NoSQL。

1. SQL 数据库

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

1.1。配置数据源

Java 的javax.sql.DataSource接口提供了一种处理数据库连接的标准方法。传统上，“数据源”使用 aURL以及一些凭据来建立数据库连接。

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

1.1.1。嵌入式数据库支持

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

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

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

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

例如，典型的 POM 依赖项如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.hsqldb</groupId>
    <artifactId>hsqldb</artifactId>
    <scope>runtime</scope>
</dependency>
您需要依赖于spring-jdbc嵌入式数据库才能自动配置。在这个例子中，它是通过 传递的spring-boot-starter-data-jpa。
如果出于某种原因，您确实为嵌入式数据库配置了连接 U​​RL，请注意确保禁用数据库的自动关闭。如果你使用 H2，你应该DB_CLOSE_ON_EXIT=FALSE这样做。如果你使用 HSQLDB，你应该确保shutdown=true没有被使用。禁用数据库的自动关闭让 Spring Boot 控制数据库何时关闭，从而确保在不再需要访问数据库时发生这种情况。

1.1.2。连接到生产数据库

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

1.1.3。数据源配置

DataSource 配置由spring.datasource.*. 例如，您可以在 中声明以下部分application.properties：

特性
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"
您至少应该通过设置spring.datasource.url属性来指定 URL。否则，Spring Boot 会尝试自动配置嵌入式数据库。
Spring Boot 可以从 URL 推导出大部分数据库的 JDBC 驱动类。如果需要指定特定的类，可以使用该spring.datasource.driver-class-name属性。
为了创建一个池DataSource，我们需要能够验证一个有效的Driver类是否可用，所以我们在做任何事情之前检查它。换句话说，如果您设置spring.datasource.driver-class-name=com.mysql.jdbc.Driver了 ，那么该类必须是可加载的。

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

例如，如果您使用Tomcat 连接池，您可以自定义许多附加设置，如下例所示：

特性
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，并在从池中借用连接之前验证连接。

1.1.4。支持的连接池

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

  1. 我们更喜欢HikariCP的性能和并发性。如果 HikariCP 可用，我们总是选择它。

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

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

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

如果你使用spring-boot-starter-jdbcor spring-boot-starter-data-jpa“starters”，你会自动获得对HikariCP.

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

额外的连接池总是可以手动配置，使用DataSourceBuilder. 如果您定义自己的DataSourcebean，则不会发生自动配置。支持以下连接池DataSourceBuilder：

  • 光CP

  • Tomcat 池化Datasource

  • 公地 DBCP2

  • 甲骨文UCP &OracleDataSource

  • Spring框架的SimpleDriverDataSource

  • H2JdbcDataSource

  • PostgreSQLPGSimpleDataSource

1.1.5。连接到 JNDI 数据源

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

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

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

1.2. 使用 JdbcTemplate

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

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

}
科特林
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.jdbc.template.max-rows=500
yaml
spring:
  jdbc:
    template:
      max-rows: 500
在幕后NamedParameterJdbcTemplate重用相同的实例。JdbcTemplate如果JdbcTemplate定义了多个并且不存在主要候选者，NamedParameterJdbcTemplate则不会自动配置。

1.3. JPA 和 Spring Data JPA

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

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

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

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

我们不会在此过多介绍 JPA 或Spring Data的细节。您可以遵循spring.io中的“使用 JPA 访问数据”指南并阅读Spring Data JPA和Hibernate参考文档。

1.3.1。实体类

传统上，JPA“实体”类在persistence.xml文件中指定。使用 Spring Boot，此文件不是必需的，而是使用“实体扫描”。默认情况下，将搜索主配置类下的所有包（带有@EnableAutoConfiguration或注释的包@SpringBootApplication）。

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

java
import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.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 java.io.Serializable
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.Id

@Entity
class City : Serializable {

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

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

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

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

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

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

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

1.3.2. Spring Data JPA 存储库

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

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

Spring Data 存储库通常从RepositoryorCrudRepository接口扩展而来。如果您使用自动配置，则从包含您的主要配置类（用@EnableAutoConfiguration或注释的那个@SpringBootApplication）的包中搜索存储库。

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

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

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

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

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

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

}

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

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

1.3.3. Spring Data Envers 存储库

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

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

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

}
科特林
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 数据库。您可以使用spring.jpa.*属性显式配置 JPA 设置。例如，要创建和删除表，您可以将以下行添加到您的application.properties:

特性
spring.jpa.hibernate.ddl-auto=create-drop
yaml
spring:
  jpa:
    hibernate.ddl-auto: "create-drop"
Hibernate 自己的内部属性名称（如果你碰巧记得更好的话）是hibernate.hbm2ddl.auto. spring.jpa.properties.*您可以通过使用（在将它们添加到实体管理器之前去除前缀）来设置它以及其他 Hibernate 本机属性。以下行显示了为 Hibernate 设置 JPA 属性的示例：
特性
spring.jpa.properties.hibernate[globally_quoted_identifiers]=true
yaml
spring:
  jpa:
    properties:
      hibernate:
        "globally_quoted_identifiers": "true"

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

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

1.3.5。在视图中打开 EntityManager

如果您正在运行 Web 应用程序，Spring Boot 默认注册OpenEntityManagerInViewInterceptor以应用“在视图中打开 EntityManager”模式，以允许在 Web 视图中延迟加载。如果你不想要这种行为，你应该spring.jpa.open-in-view在false你的application.properties.

1.4. 弹簧数据 JDBC

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

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

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

1.5。使用 H2 的 Web 控制台

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

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

1.5.1。更改 H2 控制台的路径

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

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

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

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

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

有关CSRF和标头X-Frame-Options的更多信息可以在 Spring Security Reference Guide 中找到。

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

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.requestMatcher(PathRequest.toH2Console());
        http.authorizeRequests(yourCustomAuthorization());
        http.csrf((csrf) -> csrf.disable());
        http.headers((headers) -> headers.frameOptions().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().disable()
            .headers().frameOptions().sameOrigin().and()
            .build()
    }


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

1.6. 使用 jOOQ

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

1.6.1. 代码生成

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

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

1.6.2. 使用 DSLContext

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

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


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

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


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

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

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

1.6.3. jOOQ SQL 方言

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

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

1.6.4. 自定义 jOOQ

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

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

1.7. 使用 R2DBC

反应式关系数据库连接 ( R2DBC ) 项目将反应式编程 API 引入关系数据库。R2DBCio.r2dbc.spi.Connection提供了一种使用非阻塞数据库连接的标准方法。连接是通过使用 a 提供的ConnectionFactory，类似于 aDataSource和 jdbc。

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

特性
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 的连接工厂发现中获取驱动程序。
至少应该提供网址。URL 中指定的信息优先于单个属性，即name、username和password池选项。
“操作方法”部分包括如何初始化数据库的部分。

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

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

}
科特林
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
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)
        }
    }

}

当ConnectionFactorybean 可用时，常规的 JDBCDataSource自动配置会退出。如果您想保留 JDBCDataSource自动配置，并且对在反应式应用程序中使用阻塞 JDBC API 的风险感到满意，请在您的应用程序中添加@Import(DataSourceAutoConfiguration.class)一个@Configuration类以重新启用它。

1.7.1。嵌入式数据库支持

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

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

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

1.7.2. 使用数据库客户端

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

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

}
科特林
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存储库是您可以定义以访问数据的接口。查询是根据您的方法名称自动创建的。例如，一个CityRepository接口可能会声明一个findAllByState(String state)方法来查找给定状态的所有城市。

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

Spring Data 存储库通常从RepositoryorCrudRepository接口扩展而来。如果您使用自动配置，则从包含您的主要配置类（用@EnableAutoConfiguration或注释的那个@SpringBootApplication）的包中搜索存储库。

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

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

}
科特林
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 Boot 为 Redis、MongoDB、Neo4j、Solr、Elasticsearch、Cassandra、Couchbase、LDAP 和 InfluxDB 提供自动配置。此外， Apache Geode 的Spring Boot 提供了 Apache Geode的自动配置。您可以使用其他项目，但您必须自己配置它们。请参阅spring.io/projects/spring-data中的相应参考文档。

2.1。雷迪斯

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

有一个spring-boot-starter-data-redis“启动器”可以方便地收集依赖项。默认情况下，它使用Lettuce。该启动器同时处理传统和反应式应用程序。

我们还提供了一个spring-boot-starter-data-redis-reactive“启动器”，以与其他商店保持一致，并提供响应式支持。

2.1.1。连接到 Redis

您可以像注入任何其他 Spring Bean 一样注入自动配置RedisConnectionFactory的StringRedisTemplate、 或 vanilla实例。RedisTemplate默认情况下，实例尝试连接到位于 的 Redis 服务器localhost:6379。以下清单显示了此类 bean 的示例：

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

}
科特林
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")
    }

}
您还可以注册实现LettuceClientConfigurationBuilderCustomizer更高级自定义的任意数量的 bean。 ClientResources也可以使用自定义ClientResourcesBuilderCustomizer。如果你使用 Jedis，JedisClientConfigurationBuilderCustomizer也是可以的。或者，您可以注册一个 , 或 类型的 beanRedisStandaloneConfiguration来RedisSentinelConfiguration完全RedisClusterConfiguration控制配置。

如果您添加您自己@Bean的任何自动配置类型，它会替换默认值（在 的情况下除外RedisTemplate，当排除基于 bean 名称，redisTemplate而不是其类型时）。

默认情况下，如果commons-pool2在类路径上，池连接工厂会自动配置。

2.2. MongoDB

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

2.2.1。连接到 MongoDB 数据库

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

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

}
科特林
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")
    }

}

如果您已经定义了自己MongoClient的MongoDatabaseFactory.

自动配置MongoClient是使用MongoClientSettingsbean 创建的。如果您定义了自己的MongoClientSettings，它将不加修改地使用，并且spring.data.mongodb属性将被忽略。否则 aMongoClientSettings将被自动配置并spring.data.mongodb应用属性。无论哪种情况，您都可以声明一个或多个MongoClientSettingsBuilderCustomizerbean 来微调MongoClientSettings配置。每个都将按顺序调用，MongoClientSettings.Builder用于构建MongoClientSettings.

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

特性
spring.data.mongodb.uri=mongodb://user:[email protected]:12345,mongo2.example.com:23456/test
yaml
spring:
  data:
    mongodb:
      uri: "mongodb://user:[email protected]:12345,mongo2.example.com:23456/test"

或者，您可以使用离散属性指定连接详细信息。例如，您可以在 中声明以下设置application.properties：

特性
spring.data.mongodb.host=mongoserver.example.com
spring.data.mongodb.port=27017
spring.data.mongodb.database=test
spring.data.mongodb.username=user
spring.data.mongodb.password=secret
yaml
spring:
  data:
    mongodb:
      host: "mongoserver.example.com"
      port: 27017
      database: "test"
      username: "user"
      password: "secret"
如果spring.data.mongodb.port未指定，27017则使用默认值 of。您可以从前面显示的示例中删除此行。
如果你不使用 Spring Data MongoDB，你可以注入一个MongoClientbean 而不是使用MongoDatabaseFactory. 如果您想完全控制建立 MongoDB 连接，您还可以声明自己的MongoDatabaseFactory或MongoClientbean。
如果您使用的是响应式驱动程序，则 SSL 需要 Netty。如果 Netty 可用并且要使用的工厂尚未自定义，则自动配置会自动配置此工厂。

2.2.2。Mongo模板

Spring Data MongoDB提供了一个MongoTemplate类，其设计与 Spring 的JdbcTemplate. 与 一样JdbcTemplate，Spring Boot 会自动配置一个 bean 供您注入模板，如下所示：

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

}
科特林
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")
    }

}

有关完整的详细信息，请参阅MongoOperationsJavadoc。

2.2.3。Spring Data MongoDB 存储库

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

事实上，Spring Data JPA 和 Spring Data MongoDB 共享相同的公共基础架构。您可以使用前面的 JPA 示例，假设City现在是 MongoDB 数据类而不是 JPA @Entity，它的工作方式相同，如下例所示：

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

}
科特林
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?
}
您可以使用@EntityScan注释自定义文档扫描位置。
有关 Spring Data MongoDB 的完整详细信息，包括其丰富的对象映射技术，请参阅其参考文档。

2.2.4。嵌入式 Mongo

Spring Boot 为Embedded Mongo提供自动配置。要在 Spring Boot 应用程序中使用它，请添加依赖项de.flapdoodle.embed:de.flapdoodle.embed.mongo并设置spring.mongodb.embedded.version属性以匹配应用程序将在生产中使用的 MongoDB 版本。

默认下载配置允许访问Embedded MongoVersion类中列出的大多数版本以及其他一些版本。尝试下载服务器时，配置不可访问的版本将导致错误。可以通过定义适当配置的DownloadConfigBuilderCustomizerbean 来纠正此类错误。

Mongo监听的端口可以通过设置spring.data.mongodb.port属性来配置。要使用随机分配的空闲端口，请使用值 0。MongoClient创建者MongoAutoConfiguration会自动配置为使用随机分配的端口。

如果您不配置自定义端口，则嵌入式支持默认使用随机端口（而不是 27017）。

如果类路径上有 SLF4J，Mongo 生成的输出会自动路由到名为org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo.

您可以声明自己的IMongodConfigbeanIRuntimeConfig来控制 Mongo 实例的配置和日志记录路由。可以通过声明DownloadConfigBuilderCustomizerbean 来自定义下载配置。

2.3. Neo4j

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

2.3.1。连接到 Neo4j 数据库

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

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

}
科特林
import org.neo4j.driver.Driver
import org.neo4j.driver.Transaction
import org.neo4j.driver.Values
import org.springframework.stereotype.Component

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

    // ...

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

}

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

特性
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"

自动配置Driver是使用创建的ConfigBuilder。要微调其配置，请声明一个或多个ConfigBuilderCustomizerbean。每个都将按顺序调用，ConfigBuilder用于构建Driver.

2.3.2. Spring Data Neo4j 存储库

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

与许多其他 Spring Data 模块一样，Spring Data Neo4j 与 Spring Data JPA 共享通用基础架构。您可以使用前面的 JPA 示例并将其定义City为 Spring Data Neo4j@Node而不是 JPA @Entity，并且存储库抽象以相同的方式工作，如以下示例所示：

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

}
科特林
import org.springframework.data.neo4j.repository.Neo4jRepository
import java.util.Optional

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

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

}

“ spring-boot-starter-data-neo4jStarter”支持存储库支持以及事务管理。Neo4jTemplateSpring Boot 使用or ReactiveNeo4jTemplatebean支持经典和响应式 Neo4j 存储库。当 Project Reactor 在类路径上可用时，响应式样式也会自动配置。

您可以通过分别在-bean上使用@EnableNeo4jRepositories和来自定义查找存储库和实体的位置。@EntityScan@Configuration

在使用响应式样式的应用程序中， aReactiveTransactionManager不是自动配置的。要启用事务管理，必须在您的配置中定义以下 bean：

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

}
科特林
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. 索尔

Apache Solr是一个搜索引擎。Spring Boot 为 Solr 5 客户端库提供了基本的自动配置。

2.4.1。连接到 Solr

SolrClient您可以像注入任何其他 Spring bean 一样注入自动配置的实例。默认情况下，实例尝试连接到位于 的服务器localhost:8983/solr。以下示例显示了如何注入 Solr bean：

java
import java.io.IOException;

import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.SolrPingResponse;

import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final SolrClient solr;

    public MyBean(SolrClient solr) {
        this.solr = solr;
    }

    // ...

    public SolrPingResponse someMethod() throws SolrServerException, IOException {
        return this.solr.ping("users");
    }

}
科特林
import org.apache.solr.client.solrj.SolrClient
import org.apache.solr.client.solrj.response.SolrPingResponse
import org.springframework.stereotype.Component

@Component
class MyBean(private val solr: SolrClient) {

    // ...

    fun someMethod(): SolrPingResponse {
        return solr.ping("users")
    }

}

如果您添加自己@Bean的 type SolrClient，它将替换默认值。

2.5. 弹性搜索

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

Spring Boot 支持多个客户端：

  • 官方 Java“低级”和“高级”REST 客户端

  • Spring Data 提供的ReactiveElasticsearchClientElasticsearch

Spring Boot 提供了一个专用的“Starter” spring-boot-starter-data-elasticsearch，.

2.5.1。使用 REST 客户端连接到 Elasticsearch

Elasticsearch 提供了两种不同的 REST 客户端，您可以使用它们来查询集群：模块中的低级客户端org.elasticsearch.client:elasticsearch-rest-client和模块中的高级客户端org.elasticsearch.client:elasticsearch-high-level-client。WebClient此外，Spring Boot 还为模块提供了基于 Spring Framework 的响应式客户端的支持org.springframework.data:spring-data-elasticsearch。默认情况下，客户端将以localhost:9200. 您可以使用spring.elasticsearch.*属性进一步调整客户端的配置方式，如以下示例所示：

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

如果你elasticsearch-rest-client在类路径上，Spring Boot 将自动配置并注册一个RestClientbean。如果你elasticsearch-rest-high-level-client在类路径上有一个RestHighLevelClientbean 也将被自动配置。在 Elasticsearch 弃用 后RestHighLevelClient，它的自动配置将被弃用，并将在未来的版本中删除。除了前面描述的属性之外，为了微调RestClientand RestHighLevelClient，您可以注册任意数量的 bean 来实现RestClientBuilderCustomizer更高级的自定义。要完全控制客户端的配置，请定义一个RestClientBuilderbean。

此外，如果elasticsearch-rest-client-sniffer在类路径上，aSniffer会自动配置为从正在运行的 Elasticsearch 集群中自动发现节点并将它们设置在RestClientbean 上。您可以进一步调整Sniffer配置方式，如以下示例所示：

特性
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"
使用 ReactiveElasticsearchClient 连接到 Elasticsearch

Spring Data Elasticsearch用于ReactiveElasticsearchClient以反应方式查询 Elasticsearch 实例。它建立在 WebFlux 之上WebClient，因此两者spring-boot-starter-elasticsearch和spring-boot-starter-webflux依赖项对于启用此支持都很有用。

默认情况下，Spring Boot 会自动配置并注册一个ReactiveElasticsearchClient. 除了前面描述的属性之外，这些spring.elasticsearch.webclient.*属性还可用于配置响应式特定设置，如以下示例所示：

特性
spring.elasticsearch.webclient.max-in-memory-size=1MB
yaml
spring:
  elasticsearch:
    webclient:
      max-in-memory-size: "1MB"

如果和配置属性还不够，并且您想完全控制客户端配置，您可以注册一个自定义bean。spring.elasticsearch.spring.elasticsearch.webclient.ClientConfiguration

2.5.2. 使用 Spring Data 连接 Elasticsearch

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

java
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final ElasticsearchRestTemplate template;

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

    // ...

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

}
科特林
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate
import org.springframework.stereotype.Component

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

    // ...

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

}

在存在和使用 a (通常是)spring-data-elasticsearch所需的依赖项的情况下，Spring Boot 还可以自动配置ReactiveElasticsearchClient和 a as beans。它们是其他 REST 客户端的反应式等价物。WebClientspring-boot-starter-webfluxReactiveElasticsearchTemplate

2.5.3. Spring Data Elasticsearch 存储库

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

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

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

ElasticsearchRestTemplateSpring Boot 使用or ReactiveElasticsearchTemplatebean支持经典和响应式 Elasticsearch 存储库。鉴于存在所需的依赖项，这些 bean 很可能是由 Spring Boot 自动配置的。

如果您希望使用自己的模板来支持 Elasticsearch 存储库，您可以添加自己的ElasticsearchRestTemplate或ElasticsearchOperations @Bean，只要它被命名为"elasticsearchTemplate"。同样适用于ReactiveElasticsearchTemplateand ReactiveElasticsearchOperations，带有 bean name "reactiveElasticsearchTemplate"。

您可以选择使用以下属性禁用存储库支持：

特性
spring.data.elasticsearch.repositories.enabled=false
yaml
spring:
  data:
    elasticsearch:
      repositories:
        enabled: false

2.6. 卡桑德拉

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

2.6.1。连接到 Cassandra

您可以像使用任何其他 Spring Bean 一样注入自动配置CassandraTemplate或 Cassandra实例。CqlSession这些spring.data.cassandra.*属性可用于自定义连接。通常，您提供本地数据中心名称keyspace-name以及contact-points本地数据中心名称，如以下示例所示：

特性
spring.data.cassandra.keyspace-name=mykeyspace
spring.data.cassandra.contact-points=cassandrahost1:9042,cassandrahost2:9042
spring.data.cassandra.local-datacenter=datacenter1
yaml
spring:
  data:
    cassandra:
      keyspace-name: "mykeyspace"
      contact-points: "cassandrahost1:9042,cassandrahost2:9042"
      local-datacenter: "datacenter1"

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

特性
spring.data.cassandra.keyspace-name=mykeyspace
spring.data.cassandra.contact-points=cassandrahost1,cassandrahost2
spring.data.cassandra.local-datacenter=datacenter1
yaml
spring:
  data:
    cassandra:
      keyspace-name: "mykeyspace"
      contact-points: "cassandrahost1,cassandrahost2"
      local-datacenter: "datacenter1"
这两个示例与默认端口相同9042。如果需要配置端口，请使用spring.data.cassandra.port.

Cassandra 驱动程序有自己的配置基础结构，它application.conf在类路径的根目录加载一个。

Spring Boot 默认不查找这样的文件，但可以使用spring.data.cassandra.config. 如果属性同时存在于spring.data.cassandra.*配置文件中，spring.data.cassandra.*则优先于 in。

对于更高级的驱动程序自定义，您可以注册任意数量的实现DriverConfigLoaderBuilderCustomizer. CqlSession可以使用 bean 类型进行定制CqlSessionBuilderCustomizer。
如果您使用CqlSessionBuilder创建多个CqlSessionbean，请记住构建器是可变的，因此请确保为每个会话注入一个新副本。

以下代码清单显示了如何注入 Cassandra bean：

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

}
科特林
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)
    }

}

如果您添加自己@Bean的 type CassandraTemplate，它将替换默认值。

2.6.2. Spring Data Cassandra 存储库

Spring Data 包括对 Cassandra 的基本存储库支持。目前，这比前面讨论的 JPA 存储库更受限制，需要使用@Query.

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

2.7. 沙发底座

Couchbase是一个开源、分布式、多模型 NoSQL 面向文档的数据库，针对交互式应用程序进行了优化。Spring Boot 为 Couchbase 和Spring Data Couchbase提供的抽象提供了自动配置。有“启动spring-boot-starter-data-couchbase器spring-boot-starter-data-couchbase-reactive”可以方便地收集依赖项。

2.7.1。连接到沙发底座

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

特性
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"

也可以自定义一些ClusterEnvironment设置。例如，以下配置更改了用于打开新的超时Bucket并启用 SSL 支持：

特性
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"
检查spring.couchbase.env.*属性以获取更多详细信息。要进行更多控制，ClusterEnvironmentBuilderCustomizer可以使用一个或多个 bean。

2.7.2. Spring Data Couchbase 存储库

Spring Data 包括对 Couchbase 的存储库支持。有关 Spring Data Couchbase 的完整详细信息，请参阅参考文档。

CouchbaseTemplate您可以像使用任何其他 Spring Bean 一样注入自动配置的实例，前提是CouchbaseClientFactorybean 可用。Cluster如上所述，当 a可用并且已指定存储桶名称时，就会发生这种情况：

特性
spring.data.couchbase.bucket-name=my-bucket
yaml
spring:
  data:
    couchbase:
      bucket-name: "my-bucket"

以下示例显示了如何注入CouchbaseTemplatebean：

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

}
科特林
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 来覆盖自动配置提供的那些：

  • 一个CouchbaseMappingContext @Bean名字为couchbaseMappingContext.

  • 一个CustomConversions @Bean名字为couchbaseCustomConversions.

  • 一个CouchbaseTemplate @Bean名字为couchbaseTemplate.

为了避免在您自己的配置中硬编码这些名称，您可以重用BeanNamesSpring Data Couchbase 提供的名称。例如，您可以自定义要使用的转换器，如下所示：

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

}
科特林
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.8. LDAP

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

LDAP 抽象由Spring Data LDAP提供。有一个spring-boot-starter-data-ldap“启动器”可以方便地收集依赖项。

2.8.1. 连接到 LDAP 服务器

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

特性
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.base和spring.ldap.base-environment属性。

AnLdapContextSource是根据这些设置自动配置的。如果DirContextAuthenticationStrategybean 可用，则它与 auto-configured 相关联LdapContextSource。如果您需要自定义它，例如使用 a PooledContextSource，您仍然可以注入 auto-configured LdapContextSource。确保将您的自定义标记ContextSource为@Primary以便自动配置LdapTemplate使用它。

2.8.2. Spring Data LDAP 存储库

Spring Data 包括对 LDAP 的存储库支持。有关 Spring Data LDAP 的完整详细信息，请参阅参考文档。

您还可以像使用任何其他 Spring Bean 一样注入自动配置的LdapTemplate实例，如以下示例所示：

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

}
科特林
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.8.3. 嵌入式内存中 LDAP 服务器

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

特性
spring.ldap.embedded.base-dn=dc=spring,dc=io
yaml
spring:
  ldap:
    embedded:
      base-dn: "dc=spring,dc=io"

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

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

特性
spring.ldap.embedded.base-dn[0]=dc=spring,dc=io
spring.ldap.embedded.base-dn[1]=dc=pivotal,dc=io
yaml
spring.ldap.embedded.base-dn:
  - "dc=spring,dc=io"
  - "dc=pivotal,dc=io"

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

如果你的类路径上有一个schema.ldif文件，它用于初始化服务器。如果要从其他资源加载初始化脚本，也可以使用该spring.ldap.embedded.ldif属性。

默认情况下，使用标准模式来验证LDIF文件。spring.ldap.embedded.validation.enabled您可以通过设置属性来完全关闭验证。如果您有自定义属性，您可以使用它spring.ldap.embedded.validation.schema来定义您的自定义属性类型或对象类。

2.9。涌入数据库

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

2.9.1。连接到 InfluxDB

Spring Boot 自动配置一个InfluxDB实例，前提是influxdb-java客户端在类路径上并且设置了数据库的 URL，如下例所示：

特性
spring.influx.url=https://172.0.0.1:8086
yaml
spring:
  influx:
    url: "https://172.0.0.1:8086"

如果与 InfluxDB 的连接需要用户和密码，您可以相应地设置spring.influx.user和spring.influx.password属性。

InfluxDB 依赖于 OkHttp。如果您需要在InfluxDB后台调整 http 客户端的使用，您可以注册一个InfluxDbOkHttpClientBuilderProviderbean。

如果您需要对配置进行更多控制，请考虑注册一个InfluxDbCustomizerbean。

3.接下来要读什么

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

1. see XML Configuration