Spring Boot Data中文文档

本文为官方文档直译版本。原文链接

引言

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

SQL 数据库

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

配置数据源

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

有关更多高级示例，请参阅 “操作方法” 部分，通常可以完全控制数据源的配置。

嵌入式数据库支持

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

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

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

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

例如，典型的 POM 依赖关系如下：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-jpaartifactId>
dependency>
<dependency>
    <groupId>org.hsqldbgroupId>
    <artifactId>hsqldbartifactId>
    <scope>runtimescope>
dependency>

要自动配置嵌入式数据库，你需要依赖 spring-jdbc。在本例中，它是通过 spring-boot-starter-data-jpa 临时引入的。

无论出于何种原因，如果您确实为嵌入式数据库配置了连接 URL，请注意确保数据库的自动关机功能被禁用。如果使用 H2，则应使用 DB_CLOSE_ON_EXIT=FALSE 来关闭数据库。如果使用 HSQLDB，则应确保不使用 shutdown=true。禁用数据库自动关闭功能可让 Spring Boot 控制关闭数据库的时间，从而确保在不再需要访问数据库时关闭数据库。

连接到生产数据库

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

数据源配置

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

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 属性。

要创建池化数据源，我们需要验证是否存在有效的驱动程序类，因此我们在做任何事情之前都要检查这一点。换句话说，如果你设置了 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
      max-active: 50
      test-on-borrow: true

这将使连接池在没有可用连接时等待 10000 毫秒才抛出异常，将最大连接数限制为 50，并在从连接池借用连接前验证连接。

支持的连接池

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

• 由于 HikariCP 的性能和并发性，我们更喜欢它。如果 HikariCP 可用，我们总是选择它。
• 否则，如果 Tomcat 池DataSource可用，我们就使用它。
• 否则，如果 Commons DBCP2 可用，我们就使用它。
• 如果 HikariCP、Tomcat 和 DBCP2 都不可用，而 Oracle UCP 可用，我们就使用它。

如果使用 spring-boot-starter-jdbc 或 spring-boot-starter-data-jpa “Starter”，就会自动获得 HikariCP 的依赖关系。

您可以完全绕过这种算法，通过设置 spring.datasource.type 属性来指定要使用的连接池。如果在 Tomcat 容器中运行应用程序，这一点尤为重要，因为默认情况下提供的是 tomcat-jdbc。
可以使用 DataSourceBuilder 手动配置其他连接池。如果您定义了自己的 DataSource Bean，则不会发生自动配置。DataSourceBuilder 支持以下连接池：

• HikariCP
• Tomcat pooling Datasource
• Commons DBCP2
• Oracle UCP & OracleDataSource
• Spring Framework’s SimpleDriverDataSource
• H2 JdbcDataSource
• PostgreSQL PGSimpleDataSource
• C3P0

连接到 JNDI 数据源

如果将 Spring Boot 应用程序部署到应用服务器，您可能希望使用应用服务器的内置功能配置和管理数据源，并使用 JNDI 对其进行访问。
spring.datasource.jndi-name 属性可替代 spring.datasource.url、spring.datasource.username 和 spring.datasource.password 属性，用于从特定 JNDI 位置访问数据源。例如，application.properties 中的以下部分展示了如何访问 JBoss AS 定义的数据源：

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

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

NamedParameterJdbcTemplate 在幕后重复使用同一个 JdbcTemplate 实例。如果定义了一个以上的 JdbcTemplate，且不存在主要候选 JdbcTemplate，则不会自动配置 NamedParameterJdbcTemplate。

使用 JdbcClient

Spring 的 JdbcClient 会根据 NamedParameterJdbcTemplate 的存在进行自动配置。您也可以将其直接注入自己的 Bean 中，如下例所示：

import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final JdbcClient jdbcClient;

    public MyBean(JdbcClient jdbcClient) {
        this.jdbcClient = jdbcClient;
    }

    public void doSomething() {
        this.jdbcClient ...
    }

}

如果依赖自动配置来创建底层 JdbcTemplate，客户端也会考虑到使用 spring.jdbc.template.* 属性进行的任何自定义。

JPA 和 Spring Data JPA

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

• Hibernate： 最流行的 JPA 实现之一。
• Spring Data JPA：帮助你实现基于 JPA 的存储库。
• Spring ORM： Spring Framework 的核心 ORM 支持。

我们在此不对 JPA 或 Spring Data 做太多详细介绍。您可以参考 spring.io 提供的 “使用 JPA 访问数据” 指南，并阅读 Spring Data JPA 和 Hibernate 参考文档。

实体类

传统上，JPA “Entity” 类是在 persistence.xml 文件中指定的。在 Spring Boot 中，这个文件不是必需的，而是使用 “实体扫描”。默认情况下，会扫描自动配置包。
任何注释为 @Entity、@Embeddable 或 @MappedSuperclass 的类都会被考虑。典型的实体类类似于下面的示例：

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

}

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

Spring Data JPA Repositories

Spring Data JPA Repositories是您可以定义用于访问数据的接口。JPA 查询会根据方法名称自动创建。例如，CityRepository 接口可以声明 findAllByState(String state) 方法来查找给定状态下的所有城市。
对于更复杂的查询，您可以使用 Spring Data 的 Query 注解来注解您的方法。
Spring Data 资源库通常从 Repository 或 CrudRepository 接口扩展而来。如果使用自动配置，则会在自动配置包中搜索资源库。

您可以使用 @EnableJpaRepositories 自定义查找软件源的位置。

下面的示例显示了一个典型的 Spring Data Repositories接口定义：

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

在使用延迟或懒启动时，请确保在应用上下文启动阶段之后延迟对 JPA 基础架构的任何访问。您可以使用 SmartInitializingSingleton 来调用任何需要 JPA 基础架构的初始化。对于创建为 Spring Bean 的 JPA 组件（如转换器），如果存在依赖关系，请使用 ObjectProvider 来延迟依赖关系的解析。

我们对 Spring Data JPA 还只是浅尝辄止。有关完整的详细信息，请参阅 Spring Data JPA 参考文档。

Spring Data Envers Repositories

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

}

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

创建和删除 JPA 数据库

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

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"

上例中的一行将 hibernate.globally_quoted_identifiers 属性的 true 值传递给了 Hibernate 实体管理器。
默认情况下，DDL 执行（或验证）会推迟到 ApplicationContext 启动后进行。还有一个 spring.jpa.generate-ddl 标志，但如果 Hibernate 自动配置处于活动状态，则不会使用该标志，因为 ddl-auto 设置更加精细。

在视图中打开 EntityManager

如果运行的是 Web 应用程序，Spring Boot 默认会注册 OpenEntityManagerInViewInterceptor 以应用 "Open EntityManager in View "模式，从而在 Web 视图中实现懒加载。如果不希望出现这种行为，则应在 application.properties 中将 spring.jpa.open-in-view 设置为 false。

Spring Data JDBC

Spring Data 包含对 JDBC 的存储库支持，并将为 CrudRepository 上的方法自动生成 SQL。对于更高级的查询，还提供了 @Query 注解。
如果类路径上有必要的依赖项，Spring Boot 将自动配置 Spring Data 的 JDBC 资源库。只需依赖 spring-boot-starter-data-jdbc 即可将它们添加到项目中。如有必要，您可以在应用程序中添加 @EnableJdbcRepositories 注解或 AbstractJdbConfiguration 子类，从而控制 Spring Data JDBC 的配置。

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

使用 H2 的 Web 控制台

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

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

如果不使用 Spring Boot 的开发者工具，但仍想使用 H2 的控制台，可以将 spring.h2.console.enabled 属性配置为 true。

H2 控制台仅在开发过程中使用，因此在生产过程中应注意不要将 spring.h2.console.enabled 设为 true。

更改 H2 控制台路径

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

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

H2 Console 使用框架，由于仅用于开发，因此不实施 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.securityMatcher(PathRequest.toH2Console());
        http.authorizeHttpRequests(yourCustomAuthorization());
        http.csrf((csrf) -> csrf.disable());
        http.headers((headers) -> headers.frameOptions((frame) -> frame.sameOrigin()));
        return http.build();
    }


}

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

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

使用 jOOQ

jOOQ Object Oriented Querying (jOOQ) 是 Data Geekery 的一款流行产品，它能从数据库生成 Java 代码，让您通过流畅的 API 构建类型安全的 SQL 查询。商业版和开源版均可与 Spring Boot 配合使用。

代码生成

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

<plugin>
    <groupId>org.jooqgroupId>
    <artifactId>jooq-codegen-mavenartifactId>
    <executions>
        ...
    executions>
    <dependencies>
        <dependency>
            <groupId>com.h2databasegroupId>
            <artifactId>h2artifactId>
            <version>${h2.version}version>
        dependency>
    dependencies>
    <configuration>
        <jdbc>
            <driver>org.h2.Driverdriver>
            <url>jdbc:h2:~/yourdatabaseurl>
        jdbc>
        <generator>
            ...
        generator>
    configuration>
plugin>

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

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

jOOQ SQL 语言

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

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

自定义 jOOQ

您可以通过定义自己的 DefaultConfigurationCustomizer Bean 来实现更高级的自定义，该 Bean 将在创建 org.jooq.Configuration @Bean 之前被调用。这将优先于自动配置所应用的任何内容。
如果你想完全控制 jOOQ 配置，也可以创建自己的 org.jooq.Configuration @Bean。

使用 R2DBC

反应式关系数据库连接（R2DBC）项目为关系数据库带来了反应式编程 API。R2DBC 的 io.r2dbc.spi.Connection 提供了一种处理非阻塞数据库连接的标准方法。连接通过 ConnectionFactory 提供，类似于 jdbc 的 DataSource。
ConnectionFactory 的配置由 spring.r2dbc.* 中的外部配置属性控制。例如，您可以在 application.properties 中声明以下部分：

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

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

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

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

要自定义 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 数据源自动配置就会退出。如果您想保留 JDBC 数据源自动配置，并愿意承担在反应式应用程序中使用阻塞 JDBC API 的风险，请在应用程序中的 @Configuration 类上添加 @Import(DataSourceAutoConfiguration.class) 以重新启用它。

嵌入式数据库支持

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

<dependency>
    <groupId>io.r2dbcgroupId>
    <artifactId>r2dbc-h2artifactId>
    <scope>runtimescope>
dependency>

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

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

}

Spring Data R2DBC Repositories

Spring Data R2DBC Repositories是您可以定义用于访问数据的接口。查询会根据方法名称自动创建。例如，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);

}

我们只是对 Spring Data R2DBC 蜻蜓点水。有关完整的详细信息，请参阅 Spring Data R2DBC 参考文档。

使用 NoSQL 技术

Spring Data 还提供其他项目，帮助您访问各种 NoSQL 技术，包括：

• Cassandra
• Couchbase
• Elasticsearch
• GemFire or 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 客户端提供了自动配置功能，但该功能已被弃用，因为新的 InfluxDB Java 客户端提供了自己的 Spring Boot 集成。

Redis

Redis 是一种缓存、消息代理和功能丰富的键值存储。Spring Boot 为 Lettuce 和 Jedis 客户端库以及 Spring Data Redis 在它们之上提供的抽象提供了基本的自动配置。
spring-boot-starter-data-redis "Starter"可以方便地收集依赖关系。默认情况下，它使用 Lettuce。该Starter既能处理传统应用程序，也能处理反应式应用程序。

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

连接到 Redis

您可以像注入其他 Spring Bean 一样，注入自动配置的 RedisConnectionFactory、StringRedisTemplate 或 vanilla 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.data.redis.* 属性指定自定义连接细节，如下例所示：

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

您还可以注册任意数量的实现 LettuceClientConfigurationBuilderCustomizer 的 Bean，以进行更高级的定制。客户端资源也可以使用 ClientResourcesBuilderCustomizer 进行自定义。如果使用 Jedis，还可以使用 JedisClientConfigurationBuilderCustomizer。此外，您还可以注册 RedisStandaloneConfiguration、RedisSentinelConfiguration 或 RedisClusterConfiguration 类型的 Bean，以完全控制配置。

如果您在任何自动配置类型中添加了自己的 @Bean，它将取代默认值（RedisTemplate 除外，因为排除是基于 bean 名称 redisTemplate，而不是其类型）。
默认情况下，如果类路径上有 commons-pool2，则会自动配置池连接工厂。
自动配置的 RedisConnectionFactory 可通过设置属性配置为使用 SSL 与服务器通信，如本示例所示：

spring:
  data:
    redis:
      ssl:
        enabled: true

自定义 SSL 信任材料可在 SSL bundle中配置，并应用于 RedisConnectionFactory，如本例所示：

spring:
  data:
    redis:
      ssl:
        bundle: "example"

MongoDB

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

连接到 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 配置。每个 Bean 都将与用于构建 MongoClientSettings 的 MongoClientSettings.Builder 一起被依次调用。
您可以设置 spring.data.mongodb.uri 属性来更改 URL 和配置其他设置，如复制集，如下例所示：

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

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

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

自动配置的 MongoClient 可通过设置属性配置为使用 SSL 与服务器通信，如本例所示：

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

可在 SSL bundle 中配置自定义 SSL 信任材料，并应用于 MongoClient，如本例所示：

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

如果未指定 spring.data.mongodb.port，则使用默认的 27017。你可以删除前面示例中的这一行。
也可以使用 host:port 语法将端口指定为主机地址的一部分。如果需要更改附加additional-hosts的端口，应使用这种格式。

如果不使用 Spring Data MongoDB，可以注入 MongoClient Bean，而不是使用 MongoDatabaseFactory。如果想完全控制 MongoDB 连接的建立，也可以声明自己的 MongoDatabaseFactory 或 MongoClient Bean。

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

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。

Spring Data MongoDB Repositories

Spring Data 包含对 MongoDB Repositories的支持。与前面讨论的 JPA Repositories一样，基本原则是根据方法名称自动构建查询。
事实上，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);

}

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

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

Neo4j

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

连接到 Neo4j 数据库

要访问 Neo4j 服务器，可以注入一个自动配置的 org.neo4j.driver.Driver。默认情况下，实例会尝试使用 Bolt 协议连接到 localhost:7687 上的 Neo4j 服务器。下面的示例展示了如何注入一个Neo4j驱动程序，从而访问会话：

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

}

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

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

自动配置的驱动程序是使用 ConfigBuilder 创建的。要对其配置进行微调，可声明一个或多个 ConfigBuilderCustomizer Bean。每个 Bean 将与用于创建驱动程序的 ConfigBuilder 一起依次被调用。

Spring Data Neo4j Repositories

Spring Data 包含对 Neo4j 的存储库支持。有关 Spring Data Neo4j 的完整详细信息，请参阅参考文档。
与许多其他 Spring Data 模块一样，Spring Data Neo4j 与 Spring Data JPA 共享通用基础架构。你可以参照前面的 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 使用 Neo4jTemplate 或 ReactiveNeo4jTemplate Bean 支持经典和反应式 Neo4j Repositories。当Project Reactor在类路径上可用时，反应式风格也会自动配置。
通过扫描可找到Repositories和实体。默认情况下，会扫描自动配置包。您可以分别使用 @EnableNeo4jRepositories 和 @EntityScan 来自定义查找资源库和实体的位置。

在使用反应式风格的应用程序中，不会自动配置 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);
    }

}

Elasticsearch

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

• 官方低级 REST 客户端
• 官方 Java API 客户端
• Spring Data Elasticsearch 提供的 ReactiveElasticsearchClient

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

使用 REST 客户端连接 Elasticsearch

Elasticsearch 提供两种不同的 REST 客户端，可用于查询群集：org.elasticsearch.client:elasticsearch-rest-client 模块中的底层客户端和 co.elastic.clients:elasticsearch-java 模块中的 Java API 客户端。此外，Spring Boot 还支持来自 org.springframework.data:spring-data-elasticsearch 模块的反应式客户端。默认情况下，客户端的目标地址是 localhost:9200。您可以使用 spring.elasticsearch.* 属性进一步调整客户端的配置方式，如下例所示：

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

使用 RestClient 连接 Elasticsearch

如果类路径上有elasticsearch-rest-client，Spring Boot就会自动配置并注册一个RestClient Bean。除了前面描述的属性外，要对 RestClient 进行微调，还可以注册任意数量的实现 RestClientBuilderCustomizer 的 Bean，以进行更高级的自定义。要完全控制客户端的配置，请定义一个 RestClientBuilder Bean。
此外，如果类路径上有 elasticsearch-rest-client-sniffer，就会自动配置 Sniffer，以便自动从运行中的 Elasticsearch 集群中发现节点，并将它们设置到 RestClient Bean 上。您可以进一步调整 Sniffer 的配置方式，如下例所示：

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

使用 ElasticsearchClient 连接到 Elasticsearch

如果您的类路径上有 co.elastic.clients:elasticsearch-java，Spring Boot 将自动配置并注册一个 ElasticsearchClient Bean。
ElasticsearchClient 使用的传输依赖于之前描述的 RestClient。因此，前面描述的属性可用于配置 ElasticsearchClient。此外，您还可以定义一个 RestClientOptions Bean 来进一步控制传输的行为。

使用 ReactiveElasticsearchClient 连接到 Elasticsearch

Spring Data Elasticsearch 提供 ReactiveElasticsearchClient，用于以反应方式查询 Elasticsearch 实例。如果类路径上有Spring Data Elasticsearch和Reactor，Spring Boot就会自动配置和注册ReactiveElasticsearchClient。
ReactiveElasticsearchclient 使用的传输依赖于之前描述的 RestClient。因此，前面描述的属性可用于配置 ReactiveElasticsearchClient。此外，您还可以定义 RestClientOptions Bean 来进一步控制传输的行为。

使用 Spring Data 连接 Elasticsearch

要连接到 Elasticsearch，必须定义一个 ElasticsearchClient Bean，由 Spring Boot 自动配置或由应用程序手动提供（参见前面的章节）。有了这些配置，就可以像注入其他 Spring Bean 一样注入 ElasticsearchTemplate，如下例所示：

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

}

有了 spring-data-elasticsearch 和 Reactor，Spring Boot 还可以自动配置 ReactiveElasticsearchClient 和 ReactiveElasticsearchTemplate 作为 Bean。它们相当于其他 REST 客户端的反应式客户端。

Spring Data Elasticsearch Repositories

Spring Data 包含对 Elasticsearch Repositories 的支持。与前面讨论的 JPA 资源库一样，其基本原理是根据方法名称自动为您构建查询。
事实上，Spring Data JPA 和 Spring Data Elasticsearch 共享相同的基础架构。你可以参照前面的 JPA 示例，假设 City 现在是 Elasticsearch 的 @Document 类，而不是 JPA 的 @Entity 类，它的工作方式也是一样的。
存储库和文档是通过扫描找到的。默认情况下，会扫描自动配置包。您可以分别使用 @EnableElasticsearchRepositories 和 @EntityScan 来自定义查找存储库和文档的位置。

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

Spring Boot 使用 ElasticsearchRestTemplate 或 ReactiveElasticsearchTemplate Bean 支持传统和反应式 Elasticsearch Repositories。如果存在所需的依赖关系，Spring Boot 很可能会自动配置这些 Bean。
如果您希望使用自己的模板来备份 Elasticsearch Repositories，您可以添加自己的 ElasticsearchRestTemplate 或 ElasticsearchOperations @Bean，只要将其命名为 “elasticsearchTemplate” 即可。这同样适用于 ReactiveElasticsearchTemplate 和 ReactiveElasticsearchOperations，Bean 名称为 “reactiveElasticsearchTemplate”。
您可以选择使用以下属性禁用软件源支持：

spring:
  data:
    elasticsearch:
      repositories:
        enabled: false

Cassandra

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

连接到 Cassandra

您可以注入一个自动配置的 CassandraTemplate 或 Cassandra CqlSession 实例，就像注入其他 Spring Bean 一样。spring.cassandra.* 属性可用于自定义连接。一般来说，您需要提供关键空间名称和联系点以及本地数据中心名称，如下例所示：

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

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

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

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

自动配置的 CqlSession 可通过设置属性配置为使用 SSL 与服务器通信，如本例所示：

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

自定义 SSL 信任材料可在 SSL bundle 中配置，并应用于 CqlSession，如本例所示：

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

Cassandra 驱动程序有自己的配置基础架构，可在类路径根目录下加载 application.conf。
Spring Boot 默认不查找此类文件，但可以使用 spring.cassandra.config 加载此类文件。如果某个属性同时存在于 spring.cassandra.* 和配置文件中，则 spring.cassandra.* 中的值优先。
对于更高级的驱动程序定制，您可以注册任意数量的实现 DriverConfigLoaderBuilderCustomizer 的 Bean。CqlSession 可通过 CqlSessionBuilderCustomizer 类型的 Bean 进行自定义。

如果使用 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);
    }

}

如果您添加了自己的 CassandraTemplate 类型的 @Bean，它将取代默认值。

Spring Data Cassandra Repositories

Spring Data 包含对 Cassandra 的基本存储库支持。目前，这种支持比前面讨论的 JPA 资源库更加有限，而且需要 @Query 注释的查找方法。
存储库和实体是通过扫描找到的。默认情况下，会扫描自动配置包。你可以分别使用 @EnableCassandraRepositories 和 @EntityScan 来自定义查找资源库和实体的位置。

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

Couchbase

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

连接到 Couchbase

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

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

还可以自定义某些 ClusterEnvironment 设置。例如，以下配置更改了打开新 Bucket 的超时时间，并通过引用已配置的 SSL 捆绑程序启用了 SSL bundle：

spring:
  couchbase:
    env:
      timeouts:
        connect: "3s"
      ssl:
        bundle: "example"

详情请查看 spring.couchbase.env.* 属性。要进行更多控制，可以使用一个或多个 ClusterEnvironmentBuilderCustomizer Bean。

Spring Data Couchbase Repositories

Spring Data 包含对 Couchbase 的存储库支持。
存储库和文档是通过扫描找到的。默认情况下，会扫描自动配置包。您可以分别使用 @EnableCouchbaseRepositories 和 @EntityScan 来自定义查找存储库和文档的位置。
有关 Spring Data Couchbase 的完整详细信息，请参阅参考文档。
只要有 CouchbaseClientFactory Bean，您就可以像注入其他 Spring Bean 一样注入自动配置的 CouchbaseTemplate 实例。如上所述，当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 @Bean 的 CouchbaseMappingContext。
• 一个名称为 CouchbaseCustomConversions 的自定义转换 @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()));
    }

}

LDAP

LDAP（轻量级目录访问协议）是一种开放的、厂商中立的行业标准应用协议，用于通过 IP 网络访问和维护分布式目录信息服务。Spring Boot 为任何符合标准的 LDAP 服务器提供自动配置，并支持来自 UnboundID 的嵌入式内存 LDAP 服务器。
LDAP 抽象由 Spring Data LDAP 提供。spring-boot-starter-data-ldap “Starter” 可以方便地收集依赖关系。

连接到 LDAP 服务器

要连接到 LDAP 服务器，请确保声明对 spring-boot-starter-data-ldap “Starter” 或 spring-ldap-core 的依赖，然后在应用程序属性中声明服务器的 URL，如下例所示：

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

如果需要自定义连接设置，可以使用 spring.ldap.base 和 spring.ldap.base-environment 属性。
LdapContextSource 会根据这些设置自动配置。如果 DirContextAuthenticationStrategy Bean 可用，它将与自动配置的 LdapContextSource 关联。如果需要自定义，例如使用 PooledContextSource，仍可注入自动配置的 LdapContextSource。确保将自定义的 ContextSource 标记为 @Primary，以便自动配置的 LdapTemplate 使用它。

Spring Data LDAP Repositories

Spring Data 包含对 LDAP 的存储库支持。
存储库（Repositories）和文档（Document）可通过扫描找到。默认情况下，会扫描自动配置包。您可以分别使用 @EnableLdapRepositories 和 @EntityScan 来自定义查找资源库和文档的位置。
有关 Spring Data LDAP 的完整详细信息，请参阅参考文档。
您还可以注入一个自动配置的 LdapTemplate 实例，就像注入其他 Spring Bean 一样，如下例所示：

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

}

嵌入式内存 LDAP 服务器

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

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

可以定义多个 base-dn 值，但由于区分名称通常包含逗号，因此必须使用正确的符号来定义。
在 yaml 文件中，可以使用 yaml 列表符号。在属性文件中，必须将索引作为属性名称的一部分：

spring.ldap.embedded.base-dn:
  - "dc=spring,dc=io"
  - "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 来定义自定义属性类型或对象类。

InfluxDB

InfluxDB 的自动配置已被弃用，并计划在 Spring Boot 3.4 中删除，转而使用新的 InfluxDB Java 客户端，该客户端提供自己的 Spring Boot 集成。

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

连接到 InfluxDB

只要类路径上有 influxdb-java 客户端，并使用 spring.influx.url 设置了数据库的 URL，Spring Boot 就会自动配置 InfluxDB 实例。
如果连接 InfluxDB 需要用户和密码，可以相应设置 spring.influx.user 和 spring.influx.password 属性。
InfluxDB 依赖于 OkHttp。如果需要调整 InfluxDB 在幕后使用的 http 客户端，可以注册 InfluxDbOkHttpClientBuilderProvider Bean。
如果您需要对配置进行更多控制，请考虑注册 InfluxDbCustomizer Bean。