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

1. 使用 SQL 数据库

Spring Framework 为 SQL 数据库提供了广泛的支持. 从直接使用 JdbcTemplate 进行 JDBC 访问到完全的对象关系映射 (object relational mapping) 技术,比如 Hibernate. Spring Data 提供了更多级别的功能,直接从接口创建的 Repository 实现,并使用了约定从方法名生成查询.

1.1. 配置数据源

Java 的 javax.sql.DataSource 接口提供了一个使用数据库连接的标准方法. 通常,数据源使用 URL 和一些凭据信息来建立数据库连接.

查看 “How-to” 部分 获取更多高级示例,通常您可以完全控制数据库的配置.

1.1.1. 嵌入式数据库支持

使用内嵌内存数据库来开发应用程序非常方便的. 显然,内存数据库不提供持久存储. 在应用启动时,您需要填充数据库,并在应用程序结束时丢弃数据.

How-to 部分包含了 如何初始化数据库方面的内容.

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 引入.
如果出于某些原因,您需要配置内嵌数据库的连接 URL,则应注意确保禁用数据库的自动关闭功能. 如果您使用 H2,则应该使用 DB_CLOSE_ON_EXIT=FALSE 来设置. 如果您使用 HSQLDB,则确保不使用 shutdown=true. 禁用数据库的自动关闭功能允许 Spring Boot 控制数据库何时关闭,从而确保一旦不再需要访问数据库时就触发.

1.1.2. 连接生产数据库

生产数据库连接也可以使用使用 DataSource 自动配置. Spring Boot 使用以下算法来选择一个特定的实现:

1.1.3. DataSource 配置

DataSource 配置由 spring.datasource.*. 中的外部配置属性控制。例如，你可以在 application.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 connection pool,则可以自定义许多其他设置,如下:

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

如果没有可用连接，则会将连接池设置为等待 10000ms 的释放，然后丢弃异常，请将最大连接数限制为 50，并在从池中使用它之前验证连接。

1.1.4. 连接池支持

Spring Boot 使用以下算法来选择连接池的实现:

  1. 出于性能和并发性的考虑,我们更喜欢 HikariCP 连接池. 如果 HikariCP 可用,我们总是选择它.

  2. 否则,如果 Tomcat 池 DataSource 可用,我们将使用它.

  3. 如果 HikariCP 和 Tomcat 连接池数据源不可用,但 Commons DBCP2 可用,我们将使用它.

  4. 如果没有 HikariCP，Tomcat 和 DBCP2，并且如果有 Oracle UCP，我们将使用它。

如果使用 spring-boot-starter-jdbc 或 spring-boot-starter-data-jpa “starters”, 您将自动获得对 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

1.1.5. 连接 JNDI 数据源

如果要将 Spring Boot 应用程序部署到应用服务器 (Application Server) 上,您可能想使用应用服务器的内置功能和 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.* 属性来自定义一些 template 的属性,如下:

spring:
  jdbc:
    template:
      max-rows: 500
NamedParameterJdbcTemplate 在底层重用了相同的 JdbcTemplate 实例. 如果定义了多个 JdbcTemplate 且没有声明 primary 主候选,则不会自动配置 NamedParameterJdbcTemplate.

1.3. JPA 与 Spring Data JPA

Java Persistence API (Java 持久化 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 的参考文档.

1.3.1. 实体类

通常,JPA Entity (实体) 类是在 persistence.xml 文件中指定的. 使用了 Spring Boot,该文件将不是必需的,可以使用 Entity Scanning (实体扫描) 来代替. 默认情况下,将搜索主配置类 (使用了 @EnableAutoConfiguration 或 @SpringBootApplication 注解) 下面的所有包.

任何用了 @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;

    // ... 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” 章节.

1.3.2. Spring Data JPA 存储库

Spring Data JPA 存储库 (repository) 是一个接口,您可以定义用于访问数据. JAP 查询是根据您的方法名自动创建. 例如,CityRepository 接口可以声明 findAllByState(String state) 方法来查找指定状态下的所有城市.

对于更加复杂的查询,您可以使用 Spring Data 的 Query 注解

Spring Data 存储库通常继承自 Repository 或者 CrudRepository 接口. 如果您使用了自动配置,则将从包含主配置类 (使用了 @EnableAutoConfiguration 或 @SpringBootApplication 注解) 的包中搜索存储库:

以下是一个典型的 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 存储库支持三种不同的引导模式: default、deferred 和 lazy. 要启用 deferred （延迟）或 lazy（懒）加载,请将 spring.data.jpa.repositories.bootstrap-mode 分别设置为 deferred 或 lazy. 使用延迟或懒加载时,自动配置的 EntityManagerFactoryBuilder 将使用上下文的 AsyncTaskExecutor (如果有) 作为 applicationTaskExecutor.

使用 deferred 或 lazy 加载时,请确保在应用程序上下文阶段之后,延迟对 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 扩展，如以下示例所示:

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

1.3.4. 创建和删除 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 原生属性一同设置: 
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 注解.

当 classpath 下存在必要的依赖时,Spring Boot 将自动配置 Spring Data 的 JDBC 资源库. 可以通过添加单个 spring-boot-starter-data-jdbc 依赖引入到项目中. 如有必要,可通过在应用程序中添加 @EnableJdbcRepositories 注解或 JdbcConfiguration 子类来控制 Spring Data JDBC 的配置.

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

1.5. 使用 H2 的 Web 控制台

H2 database 数据库提供了一个 基于浏览器的控制台,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 和 header 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();
    }


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

1.6. 使用 jOOQ

Java 面向对象查询 (Java Object Oriented Querying, 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;
    }


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

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

1.6.4. 自定义 jOOQ

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

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

1.7. 使用 R2DBC

响应式关系数据库连接 (R2DBC) 项目将响应式编程 API 引入关系数据库. R2DBC 的 io.r2dbc.spi.Connection 提供了一种处理非阻塞数据库连接的标准方法. 通过 ConnectionFactory 提供连接,类似于使用 jdbc 的数据源.

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 和连接池选项.
“How-to” 章节包括有关如何 初始化数据库的部分

要自定义由 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>

如果您在测试中使用此功能,则可能会注意到,整个测试套件将重复使用同一数据库,而不管您使用的应用程序上下文有多少. 如果要确保每个上下文都有一个单独的嵌入式数据库,则应将 spring.r2dbc.generate-unique-name 设置为 true.

1.7.2. 使用 DatabaseClient

Spring Data 的 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 接口扩展. 如果您使用自动配置,则会从包含您的主要配置类 (以 @EnableAutoConfiguration 或 @SpringBootApplication 注解的类) 的包中搜索存储库.

以下示例显示了典型的 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 reference documentation.

2. 使用 NoSQL 技术

Spring Data提供了其他项目来帮助您访问各种NoSQL技术,包括:

Spring Boot 为 Redis, MongoDB, Neo4j, Elasticsearch, Solr, Cassandra, Couchbase, LDAP 和 InfluxDB 提供自动配置. 此外，https://github.com/spring-projects/spring-boot-data-geode[Spring Boot for Apache Geode] 提供 Apache Geode 的自动配置。 您可以使用其他项目，但您必须自己配置它们。 请参阅 spring.io/projects/spring-data 中的相应参考文档。

2.1. Redis

Redis 是一个集缓存、消息代理和键值存储等丰富功能的数据库. Spring Boot 为 Lettuce 和 Jedis 客户端类库提供了基本自动配置, Spring Data Redis 为他们提供了上层抽象.

使用 spring-boot-starter-data-redis starter 可方便地引入相关依赖. 默认情况下,它使用 Lettuce. 该 starter 可处理传统应用程序和响应式应用程序.

我们还提供了一个 spring-boot-starter-data-redis-reactive starter,以便与其他带有响应式支持的存储保持一致.

2.1.1. 连接 Redis

您可以像所有 Spring Bean 一样注入自动配置的 RedisConnectionFactory、StringRedisTemplate 或普通的 RedisTemplate 实例. 默认情况下,实例将尝试在 localhost:6379 上连接 Redis 服务器,以下是 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");
    }

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

如果您添加了自己的任何一个自动配置类型的 @Bean,它将替换默认设置 (除了 RedisTemplate,由于排除是基于 bean 名称,而 redisTemplate 不是它的类型) . 默认情况下,如果 commons-pool2 在 classpath 上,您将获得一个连接池工厂.

2.2. MongoDB

MongoDB 是一个开源的 NoSQL 文档数据库,其使用了类似 JSON 的模式 (schema) 来替代传统基于表的关系数据. Spring Boot 为 MongoDB 提供了几种便利的使用方式,包括 spring-boot-starter-data-mongodb 和 spring-boot-starter-data-mongodb-reactive starter.

2.2.1. 连接 MongoDB 数据库

您可以注入一个自动配置的 org.springframework.data.mongodb.MongoDbFactory 来访问 MongoDB 数据库. 默认情况下,该实例将尝试在 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.

使用 MongoClientSettings 创建自动配置的 MongoClient. 要微调其配置,请声明一个或多个 MongoClientSettingsBuilderCustomizer Bean. 每个命令都将与用于构建 MongoClientSettings 的 MongoClientSettings.Builder 依次调用.

您可以通过设置 spring.data.mongodb.uri 属性来更改 URL 和配置其他设置,如副本集 (replica set) :

spring:
  data:
    mongodb:
      uri: "mongodb://user:secret@mongo1.example.com:12345,mongo2.example.com:23456/test"

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

spring:
  data:
    mongodb:
      host: "mongoserver.example.com"
      port: 27017
      database: "test"
      username: "user"
      password: "secret"
如果未指定 spring.data.mongodb.port,则使用默认值 27017. 您可以将上述示例中的改行配置删除掉.
如果您不使用 Spring Data MongoDB,则可以注入 com.mongodb.MongoClient bean 来代替 MongoDatabaseFactory. 如果要完全控制建立 MongoDB 连接,您还可以声明自己的 MongoDatabaseFactory 或者 MongoClient bean.
如果您使用的是响应式驱动,则 SSL 需要 Netty. 如果 Netty 可用且 factory 尚未自定义,则自动配置会自动配置此 factory.

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 存储库 (repository) 的支持. 与之前讨论的 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);

}
您可以使用 @EntityScan 注解来自定义文档扫描位置.
有关 Spring Data MongoDB 的完整详细内容,包括其丰富的对象关系映射技术,请参考其 参考文档.

2.2.4. 嵌入式 Mongo

Spring Boot 提供了 内嵌 Mongo的自动配置. 要在 Spring Boot 应用程序中使用它,请添加依赖 de.flapdoodle.embed:de.flapdoodle.embed.mongo 设置 spring.mongodb.embedded.version 属性以匹配 MongoDB 的版本.

默认下载配置也允许访问 Embedded Mongo’s Version 类 中列出的大多数版本 和其他一些人一样。 尝试下载服务器时，配置不可访问的版本将导致错误。 可以通过定义适当配置的 DownloadConfigBuilderCustomizer bean 来纠正此类错误。

可以使用 spring.data.mongodb.port 属性来配置 Mongo 的监听端口. 如果想随机分配空闲端口,请把值设置为 0. MongoAutoConfiguration 创建的 MongoClient 将自动配置随机分配的端口.

如果您不配置一个自定义端口,内嵌支持将默认使用一个随机端口 (而不是 27017) .

如果您的 classpath 上有 SLF4J,Mongo 产生的输出将自动路由到名为 org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo 的 logger.

您可以声明自己的 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 数据库

您可以像任何 Spring Bean 一样注入一个自动配置的 org.neo4j.driver.Driver. 默认情况下, 该实例将尝试使用在 localhost:7687 上使用 Bolt 协议连接到 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"
    authentication:
      username: "neo4j"
      password: "secret"

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

2.3.2. Spring Data Neo4j 存储库

Spring Data 包括了对 Neo4j 存储库的支持.有关 Spring Data Neo4j 的完整细节，请参阅 reference documentation.

与许多其他 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 存储库。 当 Project Reactor 在 ClassPath 上提供时，响应式也是自动配置的。

您可以在 @Configuration bean 上分别使用 @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);
    }

}

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 支持以下 HTTP 客户端:

  • 官方 Java Low Level (低级) 和 High Level (高级) REST 客户端

  • Spring Data Elasticsearch 提供的 ReactiveElasticsearchClient

Spring Boot 提供了一个 “Starter”. 您可以使用 spring-boot-starter-data-elasticsearch starter 引入使用它.

2.5.1. 使用 REST 客户端连接 Elasticsearch

Elasticsearch 提供了 两个可用于查询集群的 REST 客户端 : Spring Boot 的高级客户端来自 org.elasticsearch.client:elasticsearch-rest-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"
    socket-timeout: "10s"
    username: "user"
    password: "secret"
使用 RestClient 连接 RestHighLevelClient

如果您在类路径中有 elasticsearch-rest-high-level-client，那么也会自动配置 RestHighLevelClient bean。 除了前面描述的属性，要调整 RestHighLevelClient，您可以注册任意数量的 RestClientBuilderCustomizer 实现的 bean 以进行更高级的自定义。 要完全控制客户端的配置，请定义一个 RestClientBuilder bean。

如果您需要访问 "low" 级别的 "RestClient"，可以通过在自动配置的 RestHighLevelClient 上调用 client.getLowLevelClient() 来获取.

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

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 将自动配置并注册一个针对 localhost:9200 的 ReactiveElasticsearchClient bean. 除了前面描述的属性之外，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,必须定义由 Spring Boot 自动配置或由应用程序手动提供的 RestHighLevelClient bean (请参阅前面的部分) . 有了此配置后,可以像其他任何 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,它以相同的方式工作.

有关 Spring Data Elasticsearch 的完整详细内容,请参阅其 参考文. .

Spring Boot使用 ElasticsearchRestTemplate 或 ReactiveElasticsearchTemplate bean 支持经典和响应式式 Elasticsearch 存储库. 给定所需的依赖,最有可能由Spring Boot自动配置这些bean.

如果您希望使用自己的模板来支持 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 以及 local-datacenter 属性:

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

如果所有端口都相同,则可以使用快捷方式,仅指定主机名,如以下示例所示:

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.* 中的值优先。

对于更高级的驱动程序自定义，您可以注册任意数量的实现 DriverConfigLoaderBuilderCustomizer 的 bean。 可以使用 CqlSessionBuilderCustomizer 类型的 bean 自定义 CqlSession。
如果您使用 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,则其将替代默认值.

2.6.2. Spring Data Cassandra 存储库

Spring Data 包含了基本的 Cassandra 存储库支持. 目前,其限制要比之前讨论的 JPA 存储库要多,并且需要在 finder 方法上使用 @Query 注解.

有关 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 starter 中.

2.7.1. 连接 Couchbase

您可以通过添加 Couchbase SDK 和一些配置来轻松获取 Cluster. spring.couchbase.* 属性可用于自定义连接. 通常您会提供 connection string username 和 password:

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

还可以自定义某些 ClusterEnvironment 设置. 例如,以下配置用于打开新的 Bucket 并启用SSL支持的超时:

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 的完整详细信息,请参阅其 reference documentation.

您可以像使用其他 Spring Bean 一样注入自动配置的 CouchbaseTemplate 实例,前提是可以使用 CouchbaseClientFactory (当您 Cluster 可以并且指定了 bucket 名称时会发生这种情况,如之前所述) .

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,以覆盖自动配置提供的配置:

  • 一个名为 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 (Lightweight Directory Access Protocol,轻量级目录访问协议) 是一个开放、厂商中立的行业标准应用协议,其通过 IP 网络访问和维护分布式目录信息服务. Spring Boot 为兼容 LDAP 服务器提供了自动配置,以及支持从 UnboundID 内嵌内存式 LDAP 服务器.

Spring Data LDAP 提供了 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"
    username: "admin"
    password: "secret"

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

如果 DirContextAuthenticationStrategy bean可用,则它与自动配置的 LdapContextSource 相关联. LdapContextSource 将根据这些设置自动配置. 如果您需要自定义它,例如使用一个 PooledContextSource,则仍然可以注入自动配置的 LdapContextSource. 确保将自定义的 ContextSource 标记为 @Primary,以便自动配置的 LdapTemplate 能使用它.

2.8.2. Spring Data LDAP 存储库

Spring Data 包含了 LDAP 资源库支持. 有关 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"

可以定义多个 base-dn 值,但是,由于名称包含逗号,存在歧义,因此必须使用正确的符号来定义它们.

在 yaml 文件中,您可以使用 yaml 列表表示法,在属性文件中,必须使用索引方式:

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

默认情况下,服务器将在一个随机端口上启动,并触发常规的 LDAP 支持 (不需要指定 spring.ldap.urls 属性) .

如果您的 classpath 上存在一个 schema.ldif 文件,其将用于初始化服务器. 如果您想从不同的资源中加载脚本,可以使用 spring.ldap.embedded.ldif 属性.

默认情况下,将使用一个标准模式 (schema) 来校验 LDIF 文件. 您可以使用 spring.ldap.embedded.validation.enabled 属性来关闭所有校验. 如果您有自定义的属性,则可以使用 spring.ldap.embedded.validation.schema 来定义自定义属性类型或者对象类.

2.9. InfluxDB

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

2.9.1. 连接 InfluxDB

Spring Boot 自动配置 InfluxDB 实例,前提是 Influxdb-java 客户端在 classpath 上并且设置了数据库的 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 对各种 消息技术 的支持以及如何在您的应用程序中启用它们。