Spring Boot：数据

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

1. SQL 数据库

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

1.1. 配置 DataSource

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

Note：参见 “操作指南” 部分，获取更多高级示例，通常用于完全控制 DataSource 的配置。

1.1.1. 嵌入式数据库支持

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

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

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

Tip：如果您在测试中使用此功能，您可能会注意到相同的数据库被整个测试套件重用，而不管您使用的应用程序上下文数量。如果您希望确保每个上下文都有一个单独的嵌入式数据库，您应该将 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>

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

Note：如果出于某种原因，您确实配置了嵌入式数据库的连接 URL，请确保禁用数据库的自动关闭。如果您使用 H2，您应该使用 DB_CLOSE_ON_EXIT=FALSE 来做到这一点。如果您使用 HSQLDB，您应该确保不使用 shutdown=true。禁用数据库的自动关闭，让 Spring Boot 控制何时关闭数据库，从而确保在不再需要访问数据库时发生。

1.1.2. 连接到生产数据库

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

1.1.3. DataSource 配置

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

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

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

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

Tip：要创建池化 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

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

1.1.4. 支持的连接池

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

1. 我们优先选择 HikariCP，因为其性能和并发性。如果 HikariCP 可用，我们总是选择它。
2. 否则，如果 Tomcat 池化 DataSource 可用，我们使用它。
3. 否则，如果 Commons DBCP2 可用，我们使用它。
4. 如果 HikariCP、Tomcat 和 DBCP2 都不可用，并且 Oracle UCP 可用，我们使用它。

Tip：如果您使用 spring-boot-starter-jdbc 或 spring-boot-starter-data-jpa “starters”，您会自动获得对 HikariCP 的依赖。

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

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

• HikariCP
• Tomcat 池化 Datasource
• Commons DBCP2
• Oracle UCP 和 OracleDataSource
• Spring Framework 的 SimpleDriverDataSource
• H2 JdbcDataSource
• PostgreSQL PGSimpleDataSource
• C3P0

1.1.5. 连接到 JNDI DataSource

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

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

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

1.2. 使用 JdbcTemplate

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

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

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

spring.jdbc.template.max-rows=500

Tip：NamedParameterJdbcTemplate 在幕后重用相同的 JdbcTemplate 实例。如果定义了多个 JdbcTemplate 并且没有主候选，则不会自动配置 NamedParameterJdbcTemplate。

1.3. JPA 和 Spring Data JPA

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

• Hibernate：最受欢迎的 JPA 实现之一。
• Spring Data JPA：帮助您实现基于 JPA 的存储库。
• Spring ORM：Spring Framework 的核心 ORM 支持。

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

1.3.1. 实体类

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

任何带有 @Entity、@Embeddable 或 @MappedSuperclass 注解的类都被视为实体类。典型的实体类如下例所示：

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;

    // ... 其他成员，通常包括 @OneToMany 映射

    protected City() {
        // JPA 规范要求的无参构造函数
        // 这个是受保护的，因为它不应直接使用
    }

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

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

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

    // ... 等等
}

Note：您可以使用 @EntityScan 注解自定义实体扫描位置。参见 “将 @Entity 定义与 Spring 配置分开” 操作指南。

1.3.2. Spring Data JPA 存储库

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

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

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

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

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

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

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

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

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

1.3.3. Spring Data Envers 存储库

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

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

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

Tip：有关更多详细信息，请参阅 Spring Data Envers 参考文档。

1.3.4. 创建和删除 JPA 数据库

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

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

Tip：Hibernate 的内部属性名称（如果您碰巧记得更好）是 hibernate.hbm2ddl.auto。您可以使用 spring.jpa.properties.*（删除前缀后将它们添加到实体管理器）设置它以及其他 Hibernate 本机属性。以下行显示了设置 Hibernate 属性的示例：

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

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

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

1.3.5. 在视图中打开 EntityManager

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

1.4. Spring Data JDBC

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

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

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

1.5. 使用 H2 的 Web 控制台

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

• 您正在开发基于 servlet 的 Web 应用程序。
• com.h2database:h2 在类路径上。
• 您正在使用 Spring Boot 的开发者工具。

Note：如果您没有使用 Spring Boot 的开发者工具，但仍希望使用 H2 的控制台，您可以将 spring.h2.console.enabled 属性配置为值 true。

Tip：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 参考指南。

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

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

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

Note：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 提供的流畅 API 通过 org.jooq.DSLContext 接口启动。Spring Boot 自动配置 DSLContext 作为 Spring Bean，并将其连接到应用程序 DataSource。要使用 DSLContext，您可以将其注入，如下面的示例所示：

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

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

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

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

1.6.3. jOOQ SQL 方言

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

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

1.6.4. 自定义 jOOQ

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

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

1.7. 使用 R2DBC

响应式关系数据库连接（R2DBC）项目将响应式编程 API 引入关系数据库。R2DBC 的 io.r2dbc.spi.Connection 提供了一种标准方法来处理非阻塞数据库连接。连接由 ConnectionFactory 提供，类似于使用 DataSource 的 jdbc。

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

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

Note：您无需指定驱动类名，因为 Spring Boot 从 R2DBC 的 Connection Factory 发现中获取驱动。

Tip：至少应提供 URL。URL 中指定的信息优先于单独的属性，即 name、username、password 和池化选项。

Note：“操作指南” 部分包括一个关于如何使用基本 SQL 脚本初始化数据库的部分。

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

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

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

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

当 ConnectionFactory bean 可用时，常规 JDBC DataSource 自动配置将退出。如果您希望保留 JDBC DataSource 自动配置，并且对在响应式应用程序中使用阻塞 JDBC API 感到满意，请在应用程序中的 @Configuration 类上添加 @Import(DataSourceAutoConfiguration.class) 以重新启用它。

1.7.1. 嵌入式数据库支持

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

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

Tip：如果您在测试中使用此功能，您可能会注意到相同的数据库被整个测试套件重用，而不管您使用的应用程序上下文数量。如果您希望确保每个上下文都有一个单独的嵌入式数据库，您应该将 spring.r2dbc.generate-unique-name 设置为 true。

1.7.2. 使用 DatabaseClient

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

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

1.7.3. Spring Data R2DBC 存储库

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

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

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

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

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

Note：我们只是触及了 Spring Data R2DBC 的表面。有关完整详细信息，请参阅 Spring Data R2DBC 参考文档。

2. 使用 NoSQL 技术

Spring Data 提供了额外的项目，帮助您访问各种 NoSQL 技术，包括：

• Cassandra
• Couchbase
• Elasticsearch
• GemFire 或 Geode
• LDAP
• MongoDB
• Neo4J
• Redis

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

Spring Boot 还为 InfluxDB 和 Solr 客户端提供了自动配置。

2.1. Redis

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

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

Note：我们还提供了一个 spring-boot-starter-data-redis-reactive “Starter”，以保持与其他支持响应式的存储一致。

2.1.1. 连接到 Redis

您可以像注入任何其他 Spring Bean 一样注入自动配置的 RedisConnectionFactory、StringRedisTemplate 或普通的 RedisTemplate 实例。以下列表显示了一个这样的 bean 的示例：

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

默认情况下，该实例尝试连接到 localhost:6379 上的 Redis 服务器。您可以使用 spring.redis.* 属性指定自定义连接详细信息，如下例所示：

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

Note：您还可以注册任意数量的实现 LettuceClientConfigurationBuilderCustomizer 的 bean，以进行更高级的自定义。ClientResources 可以使用 ClientResourcesBuilderCustomizer 进行自定义。如果使用 Jedis，JedisClientConfigurationBuilderCustomizer 也可用。或者，您可以注册 RedisStandaloneConfiguration、RedisSentinelConfiguration 或 RedisClusterConfiguration 类型的 bean，以完全控制配置。

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

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

2.2. MongoDB

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

2.2.1. 连接到 MongoDB 数据库

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

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

}

如果定义了自己的 MongoClient，它将用于自动配置合适的 MongoDatabaseFactory。

自动配置的 MongoClient 是使用 MongoClientSettings bean 创建的。如果定义了自己的 MongoClientSettings，它将不加修改地使用，并且将忽略 spring.data.mongodb 属性。否则，将自动配置 MongoClientSettings，并将 spring.data.mongodb 属性应用于它。在任何一种情况下，您都可以声明一个或多个 MongoClientSettingsBuilderCustomizer bean，以微调 MongoClientSettings 配置。每个都将按顺序调用 MongoClientSettings.Builder，该构建器用于构建 MongoClientSettings。

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

spring.data.mongodb.uri=mongodb://user:secret@mongo1.example.com: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

Note：如果未指定 spring.data.mongodb.port，则默认为 27017。您可以从前面的示例中删除此行。

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

Tip：如果使用响应式驱动程序，则需要 Netty 进行 SSL。如果 Netty 可用且尚未自定义要使用的工厂，则自动配置会自动配置此工厂。

2.2.2. MongoTemplate

Spring Data MongoDB 提供了一个 MongoTemplate 类，其设计与 Spring 的 JdbcTemplate 非常相似。与 JdbcTemplate 一样，Spring Boot 为您自动配置一个 bean，以便您可以注入模板，如下所示：

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

请参阅 MongoOperations Javadoc 以获取完整详细信息。

2.2.3. Spring Data MongoDB 存储库

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

实际上，Spring Data JPA 和 Spring Data MongoDB 共享相同的通用基础设施。您可以从前面的 JPA 示例中获取 City，并假设它现在是 MongoDB 数据类而不是 JPA @Entity，它以相同的方式工作，如下例所示：

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

存储库和文档是通过扫描找到的。默认情况下，扫描自动配置包。您可以使用 @EnableMongoRepositories 和 @EntityScan 分别自定义要查找存储库和文档的位置。

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

2.2.4. 嵌入式 Mongo

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

Tip：默认下载配置允许访问 嵌入式 Mongo 的 Version 类中列出的大多数版本以及其他一些版本。配置不可访问的版本将导致在尝试下载服务器时出错。此类错误可以通过定义适当配置的 DownloadConfigBuilderCustomizer bean 来纠正。

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

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

如果类路径上有 SLF4J，Mongo 生成的输出将自动路由到名为 org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo 的日志记录器。

您可以声明自己的 IMongodConfig 和 IRuntimeConfig bean，以控制 Mongo 实例的配置和日志记录路由。下载配置可以通过声明 DownloadConfigBuilderCustomizer bean 进行自定义。

2.3. Neo4j

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

2.3.1. 连接到 Neo4j 数据库

要访问 Neo4j 服务器，您可以注入自动配置的 org.neo4j.driver.Driver。默认情况下，该实例尝试使用 Bolt 协议连接到 localhost:7687 上的 Neo4j 服务器。以下示例显示了如何注入 Neo4j Driver，该驱动程序提供对 Session 的访问：

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

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

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

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

2.3.2. Spring Data Neo4j 存储库

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

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

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

spring-boot-starter-data-neo4j “Starter” 启用了存储库支持以及事务管理。Spring Boot 支持经典和响应式 Neo4j 存储库，使用 Neo4jTemplate 或 ReactiveNeo4jTemplate bean。当类路径上存在 Project Reactor 时，也会自动配置响应式样式。

存储库和实体是通过扫描找到的。默认情况下，扫描自动配置包。您可以使用 @EnableNeo4jRepositories 和 @EntityScan 分别自定义要查找存储库和实体的位置。

Tip

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

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

2.4. Solr

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

2.4.1. 连接到 Solr

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

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

如果添加了类型为 SolrClient 的自己的 @Bean，它将替换默认值。

2.5. Elasticsearch

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

Spring Boot 支持几种客户端：

• 官方 Java “低级” 和 “高级” REST 客户端
• 由 Spring Data Elasticsearch 提供的 ReactiveElasticsearchClient

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 模块的高级客户端。此外，Spring Boot 提供了基于 Spring Framework 的 WebClient 的响应式客户端的支持，来自 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

2.5.1.1. 使用 RestClient 连接到 Elasticsearch

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

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

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

2.5.1.2. 使用 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

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

2.5.2. 使用 Spring Data 连接到 Elasticsearch

要连接到 Elasticsearch，必须定义 RestHighLevelClient bean，由 Spring Boot 自动配置或由应用程序手动提供（请参阅前面的章节）。配置完成后，可以像注入任何其他 Spring bean 一样注入 ElasticsearchRestTemplate，如下例所示：

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

在存在 spring-data-elasticsearch 和使用 WebClient 所需的依赖项（通常是 spring-boot-starter-webflux）的情况下，Spring Boot 还可以自动配置 ReactiveElasticsearchClient 和 ReactiveElasticsearchTemplate 作为 bean。它们是其他 REST 客户端的响应式等效物。

2.5.3. Spring Data Elasticsearch 存储库

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

实际上，Spring Data JPA 和 Spring Data Elasticsearch 共享相同的通用基础设施。您可以从前面的 JPA 示例中获取 City，并假设它现在是 Elasticsearch @Document 类而不是 JPA @Entity，它以相同的方式工作。

存储库和文档是通过扫描找到的。默认情况下，扫描自动配置包。您可以使用 @EnableElasticsearchRepositories 和 @EntityScan 分别自定义要查找存储库和文档的位置。

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

Spring Boot 支持经典和响应式 Elasticsearch 存储库，使用 ElasticsearchRestTemplate 或 ReactiveElasticsearchTemplate bean。最有可能的是，这些 bean 由 Spring Boot 自动配置，前提是存在所需的依赖项。

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

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

spring.data.elasticsearch.repositories.enabled=false

2.6. Cassandra

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

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

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

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

Note：这两个例子是相同的，因为端口默认为 9042。如果需要配置端口，请使用 spring.data.cassandra.port。

Tip：Cassandra 驱动程序有自己的配置基础设施，它在类路径的根目录加载一个 application.conf 文件。

Spring Boot 默认情况下不查找此类文件，但可以使用 spring.data.cassandra.config 加载一个。如果属性同时存在于 spring.data.cassandra.* 和配置文件中，spring.data.cassandra.* 中的值优先。

对于更高级的驱动程序自定义，您可以注册任意数量的实现 DriverConfigLoaderBuilderCustomizer 的 bean。CqlSession 可以使用 CqlSessionBuilderCustomizer 类型的 bean 进行自定义。

Tip：如果使用 CqlSessionBuilder 创建多个 CqlSession bean，请记住构建器是可变的，因此请确保为每个会话注入一个新副本。

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

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

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

2.6.2. Spring Data Cassandra 存储库

Spring Data 包括对 Cassandra 的基本存储库支持。目前，这比之前讨论的 JPA 存储库更有限，需要使用 @Query 注解查找方法。

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

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

2.7. Couchbase

Couchbase 是一个开源的分布式多模型 NoSQL 文档导向数据库，优化用于交互式应用程序。Spring Boot 提供了 Couchbase 的自动配置以及由 Spring Data Couchbase 提供的抽象层。有 spring-boot-starter-data-couchbase 和 spring-boot-starter-data-couchbase-reactive “Starters” 用于方便地收集依赖项。

2.7.1. 连接到 Couchbase

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

spring.couchbase.connection-string=couchbase://192.168.1.123
spring.couchbase.username=user
spring.couchbase.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

Note：查看 spring.couchbase.env.* 属性以获取更多详细信息。要获得更多控制权，可以使用一个或多个 ClusterEnvironmentBuilderCustomizer bean。

2.7.2. Spring Data Couchbase 存储库

Spring Data 包括对 Couchbase 的存储库支持。

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

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

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

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

以下示例显示了如何注入 CouchbaseTemplate bean：

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

您可以在自己的配置中定义一些 bean 来覆盖自动配置提供的 bean：

• 一个名为 couchbaseMappingContext 的 CouchbaseMappingContext @Bean。
• 一个名为 couchbaseCustomConversions 的 CustomConversions @Bean。
• 一个名为 couchbaseTemplate 的 CouchbaseTemplate @Bean。

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

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

2.8. LDAP

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

LDAP 抽象由 Spring Data LDAP 提供。有一个 spring-boot-starter-data-ldap “Starter” 用于方便地收集依赖项。

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

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

基于这些设置自动配置 LdapContextSource。如果 DirContextAuthenticationStrategy bean 可用，它将与自动配置的 LdapContextSource 关联。如果需要自定义它，例如使用 PooledContextSource，您仍然可以注入自动配置的 LdapContextSource。确保将自定义的 ContextSource 标记为 @Primary，以便自动配置的 LdapTemplate 使用它。

2.8.2. Spring Data LDAP 存储库

Spring Data 包括对 LDAP 的存储库支持。

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

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

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

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

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

Tip

可以定义多个 base-dn 值，但由于区别名通常包含逗号，因此必须使用正确的表示法。

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

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

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

如果类路径上有 schema.ldif 文件，它将用于初始化服务器。如果要从不同的资源加载初始化脚本，还可以使用 spring.ldap.embedded.ldif 属性。

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

2.9. InfluxDB

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

2.9.1. 连接到 InfluxDB

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

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

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

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

如果需要更多控制配置，请考虑注册一个 InfluxDbCustomizer bean。

3. 接下来阅读什么

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