# 数据

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

# 1. SQL 数据库
----------

[Spring Framework](https://spring.io/projects/spring-framework)为使用 SQL 数据库提供了广泛的支持，从使用`JdbcTemplate`直接访问 JDBC 到完成诸如 Hibernate 之类的“对象关系映射”技术。[Spring Data](https://spring.io/projects/spring-data)提供了一个额外的功能级别：直接从接口创建`Repository`实现，并使用约定从你的方法名称生成查询。

### 1.1.配置数据源

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

|   |有关更高级的示例，请参见[“操作指南”部分](howto.html#howto.data-access.configure-custom-datasource)，通常用于完全控制数据源的配置。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.1.1.嵌入式数据库支持

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

|   |“how-to”部分包括[关于如何初始化数据库的一节](howto.html#howto.data-initialization)。|
|---|----------------------------------------------------------------------------------------------------------------|

Spring 引导可以自动配置嵌入式[H2](https://www.h2database.com)、[HSQL](http://hsqldb.org/)和[Derby](https://db.apache.org/derby/)数据库。你不需要提供任何连接 URL。你只需要对要使用的嵌入式数据库包含一个构建依赖项。如果在 Classpath 上有多个嵌入式数据库，请设置`spring.datasource.embedded-database-connection`配置属性以控制使用哪个数据库。将属性设置为`none`将禁用嵌入式数据库的自动配置。

|   |如果你在测试中使用此功能，你可能会注意到，无论你使用的应用程序上下文的数量如何，整个测试套件都可以重用相同的数据库，如果你想确保每个上下文都有一个单独的嵌入式数据库，<br/>，你应该将`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`有一个依赖关系，才能自动配置嵌入式数据库。<br/>在本例中，它是通过`spring-boot-starter-data-jpa`传递地拉入的。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |无论出于何种原因，如果你确实为嵌入式数据库配置了连接 URL，请注意确保禁用数据库的自动关闭。<br/>如果你使用 H2，则应使用`DB_CLOSE_ON_EXIT=FALSE`，如果你使用 HSQLDB，请使用<br/>，你应该确保不使用`shutdown=true`。<br/>禁用数据库的自动关机可以在数据库关闭时进行引导控制，从而确保在不再需要访问数据库时发生这种情况。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.1.2.与生产数据库的连接

还可以通过使用池`DataSource`自动配置生产数据库连接。

#### 1.1.3.数据源配置

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

属性

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

Yaml

```
spring:
  datasource:
    url: "jdbc:mysql://localhost/test"
    username: "dbuser"
    password: "dbpass"
```

|   |你至少应该通过设置`spring.datasource.url`属性来指定 URL。<br/>否则， Spring 引导将尝试自动配置嵌入式数据库。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |Spring 引导可以从 URL 推断出大多数数据库的 JDBC 驱动程序类。<br/>如果需要指定特定的类，可以使用`spring.datasource.driver-class-name`属性。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |对于要创建的池`DataSource`，我们需要能够验证一个有效的`Driver`类是可用的，所以我们在做任何事情之前都要检查它。<br/>换句话说，如果你设置`spring.datasource.driver-class-name=com.mysql.jdbc.Driver`，那么这个类必须是可加载的。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

参见[`DataSource属性`]（https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-autofigure/SRC/main/java/org/springframework/boot/autofigure/jdbc/dasourceproperties.java）以获得更多支持的选项。无论[实际执行情况](features.html#data.sql.datasource.connection-pool)如何，这些都是标准选项。也可以通过使用它们各自的前缀（`spring.datasource.hikari.*`，`spring.datasource.tomcat.*`，`spring.datasource.dbcp2.*`，和`spring.datasource.oracleucp.*`）来微调实现特定的设置。有关更多详细信息，请参见你正在使用的连接池实现的文档。

例如，如果使用[Tomcat connection pool](https://tomcat.apache.org/tomcat-9.0-doc/jdbc-pool.html#Common_Attributes)，则可以自定义许多其他设置，如下例所示：

属性

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

Yaml

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

这将设置池等待 10000ms，然后在没有可用连接的情况下抛出异常，将最大连接数量限制为 50，并在从池中借用连接之前验证连接。

#### 1.1.4.支持的连接池

Spring 启动使用以下算法来选择具体的实现方式：

1. 我们更喜欢[Hikaricp](https://github.com/brettwooldridge/HikariCP)的性能和并发性。如果有 Hikaricp，我们总是选择它。

2. 否则，如果 Tomcat 池`DataSource`可用，则使用它。

3. 否则，如果[Commons DBCP2](https://commons.apache.org/proper/commons-dbcp/)是可用的，我们就使用它。

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 池`Datasource`

* Commons DBCP2

* Oracle UCP&`OracleDataSource`

* Spring 框架的`SimpleDriverDataSource`

* h2`JdbcDataSource`

* PostgreSQL`PGSimpleDataSource`

#### 1.1.5.连接到 JNDI 数据源

如果你将 Spring 引导应用程序部署到应用程序服务器，那么你可能希望通过使用应用程序服务器的内置功能来配置和管理你的数据源，并通过使用 JNDI 访问它。

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

属性

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

Yaml

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

Yaml

```
spring:
  jdbc:
    template:
      max-rows: 500
```

|   |`NamedParameterJdbcTemplate`在幕后重用相同的`JdbcTemplate`实例。<br/>如果定义了多个`JdbcTemplate`且不存在主要候选项，则`NamedParameterJdbcTemplate`不会自动配置。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

### 1.3. JPA 和 Spring 数据 JPA

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

* Hibernate:最流行的实现方式之一 JPA。

* Spring 数据 JPA:帮助你实现基于 JPA 的存储库。

* Spring ORM:来自 Spring 框架的核心 ORM 支持。

|   |在这里，我们不会对 JPA 或[Spring Data](https://spring.io/projects/spring-data)进行过多的详细说明。<br/>你可以按照[“Accessing Data with JPA”](https://spring.io/guides/gs/accessing-data-jpa/)中的[“Accessing Data with JPA”](https://spring.io/guides/gs/accessing-data-jpa/)指南，并阅读[Spring Data JPA](https://spring.io/projects/spring-data-jpa)和[Hibernate](https://hibernate.org/orm/documentation/)参考文档。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.3.1.实体类别

传统上， JPA“实体”类是在`persistence.xml`文件中指定的。在 Spring 启动时，这个文件不是必需的，而是使用“实体扫描”。默认情况下，将搜索主配置类下面的所有包（注释为`@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`注释自定义实体扫描位置。<br/>参见“[howto.html](howto.html#howto.data-access.separate-entity-definitions-from-spring-configuration)”操作方法。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.3.2. Spring 数据 JPA 存储库

[Spring Data JPA](https://spring.io/projects/spring-data-jpa)存储库是你可以定义以访问数据的接口。 JPA 查询是根据你的方法名称自动创建的。例如，一个`CityRepository`接口可以声明一个`findAllByState(String state)`方法来查找给定状态下的所有城市。

对于更复杂的查询，你可以使用 Spring data 的[`Query`]（https://DOCS. Spring.io/ Spring-data/ JPA/DOCS/2.6.2/api/org/springframework/data/ JPA/repository/query.html）注释来注释你的方法。

Spring 数据存储库通常扩展自[`Repository`]（https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframework/data/repository/repository.html）或[`CrudRepository`（https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframFramework/data/depository.html）接口。如果使用自动配置，那么存储库将从包含主配置类（用`@EnableAutoConfiguration`或`@SpringBootApplication`注释的类）的包中向下搜索。

下面的示例显示了典型的 Spring 数据存储库接口定义：

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

|   |当使用延迟引导或延迟引导时，请确保在应用程序上下文引导阶段之后推迟对 JPA 基础架构的任何访问。<br/>你可以使用`SmartInitializingSingleton`来调用任何需要 JPA 基础架构的初始化。<br/>对于创建为 Spring bean 的 JPA 组件（例如转换器），使用`ObjectProvider`来延迟依赖关系的解决（如果有的话）。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |我们几乎没有触及 Spring 数据 JPA 的表面。<br/>有关完整的详细信息，请参见[Spring Data JPA reference documentation](https://docs.spring.io/spring-data/jpa/docs/2.6.2/reference/html)。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.3.3. Spring 数据影响存储库

如果[Spring Data Envers](https://spring.io/projects/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 reference documentation](https://docs.spring.io/spring-data/envers/docs/2.6.2/reference/html/)。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.3.4.创建和删除 JPA 数据库

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

属性

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

Yaml

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

|   |Hibernate 自己的内部属性名称（如果你能更好地记住它的话）是`hibernate.hbm2ddl.auto`，<br/>，你可以将其与其他 Hibernate 本机属性一起设置，通过使用`spring.jpa.properties.*`（前缀在将其添加到实体管理器之前被剥离）。<br/>下面的一行显示了为 Hibernate 设置 JPA 属性的示例：|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

属性

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

Yaml

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

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

默认情况下，DDL 的执行（或验证）被推迟到`ApplicationContext`已经开始时。还有一个`spring.jpa.generate-ddl`标志，但如果 Hibernate 自动配置是活动的，则不会使用它，因为`ddl-auto`设置的粒度更细。

#### 1.3.5.在视图中打开 EntityManager

如果你正在运行一个 Web 应用程序， Spring 默认引导寄存器[`OpenEntityManagerInViewInterceptor`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/orm/ JPA/support/openentitymanagerinviewinterceptor.html）应用“Opentitymanager in view”模式，以允许在 Web 视图中进行延迟加载。如果不希望发生这种行为，则应在`application.properties`中将`spring.jpa.open-in-view`设置为`false`。

### 1.4. Spring 数据 JDBC

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

Spring 当必要的依赖关系在 Classpath 上时，启动将自动配置 Spring 数据的 JDBC 存储库。它们可以通过对`spring-boot-starter-data-jdbc`的单一依赖添加到你的项目中。如果有必要，你可以通过向应用程序添加`@EnableJdbcRepositories`注释或`JdbcConfiguration`子类来控制 Spring 数据 JDBC 的配置。

|   |有关 Spring 数据 JDBC 的完整详细信息，请参见[参考文献](https://docs.spring.io/spring-data/jdbc/docs/2.3.2/reference/html/)。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------|

### 1.5.使用 H2 的网络控制台

[H2 数据库](https://www.h2database.com)提供了一个[基于浏览器的控制台](https://www.h2database.com/html/quickstart.html#h2_console)， Spring 引导可以为你自动配置。当满足以下条件时，控制台将自动配置：

* 你正在开发一个基于 Servlet 的 Web 应用程序。

* `com.h2database:h2`在 Classpath 上。

* 你使用的是[Spring Boot’s developer tools](using.html#using.devtools)。

|   |如果你不使用 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.6.使用 Jooq

Jooq 面向对象查询（[jOOQ](https://www.jooq.org/)）是[数据极客](https://www.datageekery.com/)中的一种流行产品，它从你的数据库生成 Java 代码，并允许你通过其 Fluent API 构建类型安全的 SQL 查询。商业版和开放源代码版都可以与 Spring boot 一起使用。

#### 1.6.1.代码生成

为了使用 Jooq 类型安全查询，你需要从数据库模式生成 Java 类。你可以按照[Jooq 用户手册](https://www.jooq.org/doc/3.14.15/manual-single-page/#jooq-in-7-steps-step3)中的说明进行操作。如果你使用`jooq-codegen-maven`插件，并且还使用`spring-boot-starter-parent`“parent POM”，则可以安全地省略该插件的`<version>`标记。你还可以使用 Spring 引导定义的版本变量（例如`h2.version`）来声明插件的数据库依赖关系。下面的清单展示了一个示例：

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

#### 1.6.2.使用 DSLContext

由 Jooq 提供的 Fluent API 是通过`org.jooq.DSLContext`接口启动的。 Spring 引导自动将`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 启动只能自动配置由开源版本的 Jooq 支持的方言。|
|---|------------------------------------------------------------------------------------------|

#### 1.6.4.定制 Jooq

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

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

### 1.7.使用 R2DBC

反应式关系数据库连接（[R2DBC](https://r2dbc.io)）项目将反应式编程 API 引入到关系数据库中。R2DBC 的`io.r2dbc.spi.Connection`提供了一种处理非阻塞数据库连接的标准方法。使用`ConnectionFactory`提供连接，类似于使用 JDBC 提供`DataSource`。

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

属性

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

Yaml

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

|   |你不需要指定驱动程序类名，因为 Spring Boot 从 R2DBC 的连接工厂发现获得驱动程序。|
|---|-------------------------------------------------------------------------------------------------------------------------------|

|   |至少应该提供 URL。<br/>URL 中指定的信息优先于单个属性，即`name`、`username`、`password`和池选项。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |“how-to”部分包括[关于如何初始化数据库的一节](howto.html#howto.data-initialization.using-basic-sql-scripts)。|
|---|----------------------------------------------------------------------------------------------------------------------------------------|

要自定义由`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 的风险感到满意，那么在应用程序中的`@Import(DataSourceAutoConfiguration.class)`类上添加`@Import(DataSourceAutoConfiguration.class)`以重新启用它。

#### 1.7.1.嵌入式数据库支持

与[JDBC 支持](features.html#data.sql.datasource.embedded)类似， Spring 引导可以自动配置嵌入式数据库以用于被动使用。你不需要提供任何连接 URL。你只需要对要使用的嵌入式数据库包含一个构建依赖项，如以下示例所示：

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

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

#### 1.7.2.使用 DatabaseClient

a`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 数据 R2DBC 存储库

[Spring Data R2DBC](https://spring.io/projects/spring-data-r2dbc)存储库是你可以定义以访问数据的接口。查询是根据你的方法名称自动创建的。例如，`CityRepository`接口可以声明一个`findAllByState(String state)`方法来查找给定州中的所有城市。

对于更复杂的查询，你可以使用 Spring data 的[`Query`]（https://DOCS. Spring.io/ Spring-data/r2dbc/DOCS/1.4.2/api/org/springframework/data/r2dbc/repository/query.html）注释来注释你的方法。

Spring 数据存储库通常扩展自[`Repository`]（https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframework/data/repository/repository.html）或[`CrudRepository`]（https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframform/data/repository.html）接口。如果使用自动配置，那么存储库将从包含主配置类（用`@EnableAutoConfiguration`或`@SpringBootApplication`注释的类）的包中向下搜索。

下面的示例显示了典型的 Spring 数据存储库接口定义：

```
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 数据 R2DBC 的表面。有关完整的详细信息，请参见[Spring Data R2DBC reference documentation](https://docs.spring.io/spring-data/r2dbc/docs/1.4.2/reference/html/)。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

## 2. 使用 NoSQL 技术
----------

Spring Data 提供了帮助你访问各种 NoSQL 技术的附加项目，这些技术包括：

* [MongoDB](https://spring.io/projects/spring-data-mongodb)

* [Neo4J](https://spring.io/projects/spring-data-neo4j)

* [Elasticsearch](https://spring.io/projects/spring-data-elasticsearch)

* [Redis](https://spring.io/projects/spring-data-redis)

* [GemFire](https://spring.io/projects/spring-data-gemfire)或[Geode](https://spring.io/projects/spring-data-geode)

* [Cassandra](https://spring.io/projects/spring-data-cassandra)

* [Couchbase](https://spring.io/projects/spring-data-couchbase)

* [LDAP](https://spring.io/projects/spring-data-ldap)

Spring Boot 为 Redis、MongoDB、NEO4J、SOLR、ElasticSearch、Cassandra、CouchBase、LDAP 和 InfluxDB 提供了自动配置。你可以使用其他项目，但必须自己配置它们。请参阅[spring.io/projects/spring-data](https://spring.io/projects/spring-data)上的相应参考文档。

### 2.1.雷迪斯

[Redis](https://redis.io/)是一个缓存、消息代理和功能丰富的键值存储。 Spring Boot 为[Lettuce](https://github.com/lettuce-io/lettuce-core/)和[Jedis](https://github.com/xetorthio/jedis/)客户端库以及[Spring Data Redis](https://github.com/spring-projects/spring-data-redis)在它们之上提供的抽象提供了基本的自动配置。

有一个`spring-boot-starter-data-redis`“starter”，可以方便地收集依赖项。默认情况下，它使用[Lettuce](https://github.com/lettuce-io/lettuce-core/)。该启动器同时处理传统应用程序和被动应用程序。

|   |我们还提供了`spring-boot-starter-data-redis-reactive`“starter”，以便与具有反应性支持的其他存储保持一致。|
|---|----------------------------------------------------------------------------------------------------------------------------------|

#### 2.1.1.连接到 Redis

可以像其他任何实例 Spring  Bean 一样，注入一个自动配置的`RedisConnectionFactory`、`StringRedisTemplate`或 vanilla`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`进行自定义。<br/>如果你使用 JEDIS，`JedisClientConfigurationBuilderCustomizer`也是可用的。<br/>或者，你可以注册类型`RedisStandaloneConfiguration`的 Bean，`RedisSentinelConfiguration`，或`RedisClusterConfiguration`以完全控制配置。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

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

默认情况下，如果`commons-pool2`在 Classpath 上，则自动配置池连接工厂。

### 2.2.MongoDB

[MongoDB](https://www.mongodb.com/)是一个开源的 NoSQL 文档数据库，它使用类似 JSON 的模式，而不是传统的基于表的关系数据。 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`的`MongoClientSettings.Builder`。

你可以设置`spring.data.mongodb.uri`属性来更改 URL 并配置其他设置，例如*复制集*，如下例所示：

属性

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

Yaml

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

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

属性

```
spring.data.mongodb.host=mongoserver.example.com
spring.data.mongodb.port=27017
spring.data.mongodb.database=test
spring.data.mongodb.username=user
spring.data.mongodb.password=secret
```

Yaml

```
spring:
  data:
    mongodb:
      host: "mongoserver.example.com"
      port: 27017
      database: "test"
      username: "user"
      password: "secret"
```

|   |如果没有指定`spring.data.mongodb.port`，则使用`27017`的默认值。<br/>你可以从前面显示的示例中删除这一行。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------|

|   |如果不使用 Spring dataMongoDB，则可以注入<gtr="328"/> Bean 而不是使用<gtr="329"/>。<gtr="332"/>如果你想完全控制建立 MongoDB 连接，还可以声明你自己的<gtr="330"/>或<gtr="331"/> Bean。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |如果你使用的是反应式驱动程序，则 SSL 需要 Netty。<br/>如果 Netty 可用，并且使用的工厂尚未自定义，则自动配置将自动配置该工厂。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 2.2.2.MongoTemplate

[Spring Data MongoDB](https://spring.io/projects/spring-data-mongodb)提供了一个[`MongoTemplate`]（https://DOCS. Spring.io/ Spring-data/MongoDB/DOCS/3.3.2/api/org/SpringFramework/data/MongoDB/Core/MongoTemplate.html）类，其设计与 Spring 的`JdbcTemplate`非常相似。与`JdbcTemplate`一样， Spring 引导自动配置一个 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]（https://DOCS. Spring.io/ Spring-data/MongoDB/DOCS/3.3.2/api/org/SpringFramework/data/MongoDB/Core/MongoOperations.html）。

#### 2.2.3. Spring 数据 MongoDB 存储库

Spring 数据包括对 MongoDB 的存储库支持。与前面讨论的 JPA 存储库一样，基本原理是基于方法名自动构造查询。

实际上， Spring 数据 JPA 和 Spring 数据 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 的完整详细信息，包括其丰富的对象映射技术，请参见其[参考文献](https://spring.io/projects/spring-data-mongodb)。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 2.2.4.嵌入式 Mongo

Spring Boot 提供了[嵌入式 Mongo](https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo)的自动配置。要在 Spring 引导应用程序中使用它，请在`de.flapdoodle.embed:de.flapdoodle.embed.mongo`上添加一个依赖项，并将`spring.mongodb.embedded.version`属性设置为与你的应用程序将在生产中使用的 MongoDB 版本匹配。

|   |默认的下载配置允许访问[Embedded Mongo 的`Version`类]中列出的大多数版本（https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo/blob/de.flapdoodle.embed.mongo-3.0.0/SRC/main/java/de/flapdoodle/embed/mongo/do/dismission/version.java）<br/>在试图下载服务器时，配置一个不可访问的版本将导致一个错误。<br/>这样的错误可以通过定义一个适当配置的`DownloadConfigBuilderCustomizer` Bean 来纠正。|
|---| |

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

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

如果在 Classpath 上有 SLF4J，则 Mongo 产生的输出将自动路由到名为`org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo`的记录器。

你可以声明自己的`IMongodConfig`和`IRuntimeConfig`bean 来控制 Mongo 实例的配置和日志路由。可以通过声明`DownloadConfigBuilderCustomizer` Bean 来定制下载配置。

### 2.3.NEO4J

[Neo4j](https://neo4j.com/)是一个开源的 NoSQL 图数据库，它使用由第一类关系连接的节点的丰富数据模型，与传统的 RDBMS 方法相比，该模型更适合于连接的大数据。 Spring Boot 为使用 NEO4j 提供了几种便利，包括`spring-boot-starter-data-neo4j`“starter”。

#### 2.3.1.连接到 NEO4J 数据库

要访问 NEO4J 服务器，可以插入自动配置的`org.neo4j.driver.Driver`。默认情况下，实例尝试使用 Bolt 协议连接到 NEO4J 服务器`localhost:7687`。下面的示例展示了如何注入一个 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
```

Yaml

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

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

#### 2.3.2. Spring 数据 NEO4J 存储库

Spring 数据存储库包括对 NEO4j 的支持。有关 Spring 数据 NEO4j 的完整详细信息，请参见[参考文献](https://docs.spring.io/spring-data/neo4j/docs/6.2.2/reference/html/)。

Spring 数据 NEO4J 与 Spring 数据共享公共基础设施 JPA，就像许多其他 Spring 数据模块所做的那样。你可以从前面的 JPA 示例中将`City`定义为 Spring 数据 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 使用`Neo4jTemplate`或`ReactiveNeo4jTemplate`bean，启动同时支持经典的和反应的 NEO4j 存储库。 Classpath 上的项目反应器是可用的时，反应方式也是自动配置的。

你可以通过在`@Configuration`- Bean 上分别使用`@EnableNeo4jRepositories`和`@EntityScan`来定制查找存储库和实体的位置。

|   |在使用反应样式的应用程序中，a`ReactiveTransactionManager`不是自动配置的。<br/>要启用事务管理，必须在你的配置中定义以下 Bean:<br/><br/>```<br/>import org.neo4j.driver.Driver;<br/><br/>import org.springframework.context.annotation.Bean;<br/>import org.springframework.context.annotation.Configuration;<br/>import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider;<br/>import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager;<br/><br/>@Configuration(proxyBeanMethods = false)<br/>public class MyNeo4jConfiguration {<br/><br/>    @Bean<br/>    public ReactiveNeo4jTransactionManager reactiveTransactionManager(Driver driver,<br/>            ReactiveDatabaseSelectionProvider databaseNameProvider) {<br/>        return new ReactiveNeo4jTransactionManager(driver, databaseNameProvider);<br/>    }<br/><br/>}<br/><br/>```|
|---| |

### 2.4.SOLR

[阿帕奇 SOLR](https://lucene.apache.org/solr/)是一个搜索引擎。 Spring 启动为 SOLR5 的客户端库提供了基本的自动配置。

#### 2.4.1.连接到 SOLR

你可以注入一个自动配置的`SolrClient`实例，就像你将注入任何其他 Spring  Bean 实例一样。默认情况下，实例尝试连接到`[localhost:8983/solr](http://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");
    }

}

```

如果你添加你自己的`@Bean`类型的`SolrClient`，它将替换缺省值。

### 2.5.Elasticsearch

[Elasticsearch](https://www.elastic.co/products/elasticsearch)是一个开源、分布式、RESTful 搜索和分析引擎。 Spring Boot 为 ElasticSearch 客户端提供了基本的自动配置。

Spring Boot 支持多个客户端：

* 官方的 Java“low level”和“high level”REST 客户端

* Spring Data ElasticSearch 提供的`ReactiveElasticsearchClient`

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

#### 2.5.1.使用 REST 客户端连接到 ElasticSearch

ElasticSearch 附带[两个不同的 REST 客户机](https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/index.html)，你可以使用它来查询集群：“低级别”客户端和“高级别”客户端。 Spring Boot 提供对“高级别”客户端的支持，该客户端附带`org.elasticsearch.client:elasticsearch-rest-high-level-client`。此外， Spring Boot 基于 Spring Framework 的`WebClient`提供对反应式客户端的支持，该客户端附带`org.springframework.data:spring-data-elasticsearch`。默认情况下，客户机将以`[localhost:9200](http://localhost:9200)`为目标。你可以使用`spring.elasticsearch.*`属性来进一步优化客户机的配置方式，如以下示例所示：

属性

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

Yaml

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

##### 使用 resthigLevelClient 连接到 ElasticSearch####

如果在 Classpath 上有`elasticsearch-rest-high-level-client`， Spring 引导将自动配置并注册一个`RestHighLevelClient` Bean。除了前面描述的属性之外，要微调`RestHighLevelClient`，你可以注册任意数量的 bean，这些 bean 实现`RestClientBuilderCustomizer`以进行更高级的自定义。要完全控制其注册，请定义`RestClientBuilder` Bean。

|   |如果你的应用程序需要访问“low level”`RestClient`，则可以通过在自动配置的`client.getLowLevelClient()`上调用`client.getLowLevelClient()`来获得它。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|

此外，如果`elasticsearch-rest-client-sniffer`在 Classpath 上，则`Sniffer`被自动配置为自动从正在运行的 ElasticSearch 集群中发现节点，并将它们设置在`RestHighLevelClient` Bean 上。你可以进一步调整`Sniffer`的配置方式，如以下示例所示：

属性

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

Yaml

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

##### 使用 ReactiveElasticSearchClient 连接到 ElasticSearch####

[Spring Data Elasticsearch](https://spring.io/projects/spring-data-elasticsearch)提供`ReactiveElasticsearchClient`用于以反应方式查询 ElasticSearch 实例。它是建立在 WebFlux 的`WebClient`之上的，因此`spring-boot-starter-elasticsearch`和`spring-boot-starter-webflux`依赖关系都有助于启用此支持。

默认情况下， Spring 启动将自动配置并注册`ReactiveElasticsearchClient`。除了前面描述的属性外，`spring.elasticsearch.webclient.*`属性还可用于配置特定于反应性的设置，如以下示例所示：

属性

```
spring.elasticsearch.webclient.max-in-memory-size=1MB
```

Yaml

```
spring:
  elasticsearch:
    webclient:
      max-in-memory-size: "1MB"
```

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

#### 2.5.2.通过使用 Spring 数据 #### 连接到 ElasticSearch

要连接到 ElasticSearch，必须定义一个`RestHighLevelClient` Bean，通过 Spring 引导自动配置，或者由应用程序手动提供（请参见前面的部分）。有了这种配置，`ElasticsearchRestTemplate`可以像任何其他 Spring  Bean 一样注入，如以下示例所示：

```
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 引导还可以自动配置一个[ReactiveElasticSearchClient](features.html#data.nosql.elasticsearch.connecting-using-rest.webclient)和一个`ReactiveElasticsearchTemplate`作为 bean。他们相当于其他 REST 客户的被动反应。

#### 2.5.3. Spring 数据弹性搜索库

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

实际上， Spring 数据 JPA 和 Spring 数据弹性搜索共享相同的公共基础设施。你可以以前面的 JPA 为例，假设`City`现在是一个 ElasticSearch`@Document`类，而不是 JPA `@Entity`，它以同样的方式工作。

|   |有关 Spring 数据 ElasticSearch 的完整详细信息，请参见[参考文献](https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/)。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|

Spring Boot 使用`ElasticsearchRestTemplate`或`ReactiveElasticsearchTemplate`bean，支持经典的和反应的 Elasticsearch 存储库。考虑到存在所需的依赖关系，这些 bean 很可能是通过 Spring 引导自动配置的。

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

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

属性

```
spring.data.elasticsearch.repositories.enabled=false
```

Yaml

```
spring:
  data:
    elasticsearch:
      repositories:
        enabled: false
```

### 2.6.卡桑德拉

[Cassandra](https://cassandra.apache.org/)是一个开源的分布式数据库管理系统，旨在处理跨许多商品服务器的大量数据。 Spring Boot 提供了对 Cassandra 的自动配置以及[Spring Data Cassandra](https://github.com/spring-projects/spring-data-cassandra)在其之上提供的抽象。有一个`spring-boot-starter-data-cassandra`“starter”可以方便地收集依赖项。

#### 2.6.1.连接到 Cassandra

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

属性

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

Yaml

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

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

属性

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

Yaml

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

|   |这两个示例与端口默认设置`9042`相同。<br/>如果需要配置端口，请使用`spring.data.cassandra.port`。|
|---|----------------------------------------------------------------------------------------------------------------------------------------|

|   |Cassandra 驱动程序有自己的配置基础结构在 Classpath 的根位置加载`application.conf`。<br/><br/> Spring boot 默认情况下不会查找这样的文件，但是可以使用`spring.data.cassandra.config`加载一个文件。<br/>如果一个属性在`spring.data.cassandra.*`和配置文件中都存在，`spring.data.cassandra.*`中的值优先。<br/><br/>对于更高级的驱动程序自定义，你可以注册任意数量的实现`DriverConfigLoaderBuilderCustomizer`的 bean。<br/>`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);
    }

}

```

如果你添加你自己的`@Bean`类型的`CassandraTemplate`，它将替换缺省值。

#### 2.6.2. Spring 数据卡桑德拉存储库

Spring 数据包括对 Cassandra 的基本存储库支持。目前，这比前面讨论的 JPA 存储库更加有限，并且需要用`@Query`注释查找方法。

|   |有关 Spring 数据 Cassandra 的完整详细信息，请参见[参考文献](https://docs.spring.io/spring-data/cassandra/docs/)。|
|---|-------------------------------------------------------------------------------------------------------------------------------------|

### 2.7.Couchbase

[Couchbase](https://www.couchbase.com/)是一个开源的、分布式的、多模型的面向 NoSQL 文档的数据库，它为交互式应用程序进行了优化。 Spring Boot 提供了对 CouchBase 的自动配置以及由[Spring Data Couchbase](https://github.com/spring-projects/spring-data-couchbase)提供的在其之上的抽象。有`spring-boot-starter-data-couchbase`和`spring-boot-starter-data-couchbase-reactive`“启动器”，可以方便地收集依赖项。

#### 2.7.1.连接到 Couchbase

你可以通过添加 CouchBase SDK 和一些配置来获得`Cluster`。`spring.couchbase.*`属性可用于自定义连接。通常，你提供[连接字符串](https://github.com/couchbaselabs/sdk-rfcs/blob/master/rfc/0011-connection-string.md)、用户名和密码，如以下示例所示：

属性

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

Yaml

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

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

属性

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

Yaml

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

|   |查看`spring.couchbase.env.*`属性以获得更多详细信息。<br/>要获得更多控制权，可以使用一个或多个`ClusterEnvironmentBuilderCustomizer`bean。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 2.7.2. Spring 数据 CouchBase 存储库

Spring 数据包括对 CouchBase 的存储库支持。有关 Spring Data Couchbase 的完整详细信息，请参见[参考文献](https://docs.spring.io/spring-data/couchbase/docs/4.3.2/reference/html/)。

你可以注入一个自动配置的`CouchbaseTemplate`实例，就像使用任何其他 Spring  Bean 一样，前提是`CouchbaseClientFactory` Bean 是可用的。如上所述，当`Cluster`可用时，并且指定了一个 bucket 名称时，就会发生这种情况：

属性

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

Yaml

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

* a`CouchbaseMappingContext``@Bean`，其名称为`couchbaseMappingContext`。

* a`CustomConversions``@Bean`，其名称为`couchbaseCustomConversions`。

* a`CouchbaseTemplate``@Bean`，其名称为`couchbaseTemplate`。

为了避免在自己的配置中对这些名称进行硬编码，你可以重用 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](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol)（轻量级目录访问协议）是一种开放的、与供应商无关的行业标准应用程序协议，用于在 IP 网络上访问和维护分布式目录信息服务。 Spring 启动提供了对任何兼容的 LDAP 服务器的自动配置，以及对来自[UnboundID](https://ldap.com/unboundid-ldap-sdk-for-java/)的嵌入式内存中 LDAP 服务器的支持。

LDAP 抽象由[Spring Data LDAP](https://github.com/spring-projects/spring-data-ldap)提供。有一个`spring-boot-starter-data-ldap`“starter”，可以方便地收集依赖项。

#### 2.8.1.连接到 LDAP 服务器

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

属性

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

Yaml

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

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

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

#### 2.8.2. Spring 数据 LDAP 存储库

Spring 数据包括对 LDAP 的存储库支持。有关 Spring 数据 LDAP 的完整详细信息，请参见[参考文献](https://docs.spring.io/spring-data/ldap/docs/1.0.x/reference/html/)。

还可以像使用任何其他 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 引导支持[UnboundID](https://ldap.com/unboundid-ldap-sdk-for-java/)中的内存中 LDAP 服务器的自动配置。要配置服务器，请向`com.unboundid:unboundid-ldapsdk`添加一个依赖项，并声明一个`spring.ldap.embedded.base-dn`属性，如下所示：

Properties

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

Yaml

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

|   |可以定义多个 base-dn 值，但是，由于专有名称通常包含逗号，因此必须使用正确的符号来定义它们。<br/><br/>在 YAML 文件中，可以使用 YAML 列表符号。在属性文件中，必须将索引作为属性名称的一部分包括在内：<br/><br/>属性<br/><br/><br/><br/>yaml<br/>```<br/>spring.ldap.embedded.base-dn:<br/>  - "dc=spring,dc=io"<br/>  - "dc=pivotal,dc=io"<br/>```|
|---| |

默认情况下，服务器从一个随机端口启动，并触发常规的 LDAP 支持。不需要指定`spring.ldap.urls`属性。

如果在你的 Classpath 上有一个`schema.ldif`文件，它将用于初始化服务器。如果希望从其他资源加载初始化脚本，还可以使用`spring.ldap.embedded.ldif`属性。

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

### 2.9.影响 b

[InfluxDB](https://www.influxdata.com/)是一个开放源代码的时间序列数据库，该数据库经过优化，可用于快速、高可用性地存储和检索操作监控、应用度量、物联网传感器数据和实时分析等领域的时间序列数据。

#### 2.9.1.连接到 InfluxDB

Spring 引导自动配置`InfluxDB`实例，前提是`influxdb-java`客户端在 Classpath 上并且设置了数据库的 URL，如以下示例所示：

Properties

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

Yaml

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

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

InfluxDB 依赖于 OkHTTP。如果你需要调优幕后使用的 HTTP 客户端`InfluxDB`，则可以注册一个`InfluxDbOkHttpClientBuilderProvider` Bean。

如果需要对配置进行更多控制，可以考虑注册`InfluxDbCustomizer` Bean。

## 3. 接下来要读什么？
----------

你现在应该对如何在各种数据技术中使用 Spring 引导有了一种感觉。从这里，你可以了解 Spring boot 对各种[消息传递技术](messaging.html#messaging)的支持，以及如何在应用程序中启用它们。

