# 9.2. 使用 NoSQL 技术

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

* [Cassandra](https://spring.io/projects/spring-data-cassandra)
* [Couchbase](https://spring.io/projects/spring-data-couchbase)
* [Elasticsearch](https://spring.io/projects/spring-data-elasticsearch)
* [GemFire](https://spring.io/projects/spring-data-gemfire) 或[Geode](https://spring.io/projects/spring-data-geode)
* [LDAP](https://spring.io/projects/spring-data-ldap)
* [MongoDB](https://spring.io/projects/spring-data-mongodb)
* [Neo4J](https://spring.io/projects/spring-data-neo4j)
* [Redis](https://spring.io/projects/spring-data-redis)

其中，Spring Boot 为 Cassandra、Couchbase、Elasticsearch、LDAP、MongoDB、Neo4J 和 Redis 提供自动配置。此外，[Spring Boot for Apache Geode](https://github.com/spring-projects/spring-boot-data-geode)为 Apache Geode提供[自动配置](https://docs.spring.io/spring-boot-data-geode-build/2.0.x/reference/html5/#geode-repositories)。您可以使用其他项目，但必须自己配置它们。[请参阅spring.io/projects/spring-data](https://spring.io/projects/spring-data)上的相应参考文档。

Spring Boot 还为 InfluxDB 客户端提供自动配置，但它已被弃用，取而代之的是提供自己的 Spring Boot 集成的[新 InfluxDB Java 客户端。](https://github.com/influxdata/influxdb-client-java)

**9.2.1. Redis**

[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”，以便与其他存储保持一致并提供反应性支持。

**连接到 Redis**

您可以像注入任何其他 Spring Bean 一样注入自动配置的`RedisConnectionFactory`、`StringRedisTemplate`或普通 `RedisTemplate` 实例。以下清单显示了此类 bean 的示例：

```
@Component
public class MyBean {
​
    private final StringRedisTemplate template;
​
    public MyBean(StringRedisTemplate template) {
        this.template = template;
    }
​
    // ...
​
}
```

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

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

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

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

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

通过设置属性，可以将自动配置`RedisConnectionFactory`配置为使用 SSL 与服务器进行通信，如下例所示：

```
spring.data.redis.ssl.enabled=true
```

[可以在SSL 捆绑包](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#features.ssl)中配置自定义 SSL 信任材料并将其应用到`RedisConnectionFactory`如以下示例：

```
spring.data.redis.ssl.bundle=example
```

**9.2.2. MongoDB**

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

**连接到 MongoDB 数据库**

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

```
@Component
public class MyBean {
​
    private final MongoDatabaseFactory mongo;
​
    public MyBean(MongoDatabaseFactory mongo) {
        this.mongo = mongo;
    }
​
    // ...
​
}
```

如果您定义了自己的`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:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
```

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

```
spring.data.mongodb.host=mongoserver1.example.com
spring.data.mongodb.port=27017
spring.data.mongodb.additional-hosts[0]=mongoserver2.example.com:23456
spring.data.mongodb.database=test
spring.data.mongodb.username=user
spring.data.mongodb.password=secret
```

通过设置属性，可以将自动配置`MongoClient`配置为使用 SSL 与服务器进行通信，如下例所示：

```
spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
spring.data.mongodb.ssl.enabled=true
```

[可以在SSL 捆绑包](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#features.ssl)中配置自定义 SSL 信任材料并将其应用到`MongoClient`以下示例中：

```
spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
spring.data.mongodb.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 供您注入模板，如下所示：

```
@Component
public class MyBean {
​
    private final MongoTemplate mongoTemplate;
​
    public MyBean(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }
​
    // ...
​
}
```

有关完整详细信息，请参阅[`MongoOperations`Javadoc](https://docs.spring.io/spring-data/mongodb/docs/4.2.0/api/org/springframework/data/mongodb/core/MongoOperations.html)。

**Spring Data MongoDB 存储库**

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

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

```
public interface CityRepository extends Repository<City, Long> {
​
    Page<City> findAll(Pageable pageable);
​
    City findByNameAndStateAllIgnoringCase(String name, String state);
​
}
```

通过扫描找到存储库和文档。默认情况下，扫描[自动配置包。](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using.auto-configuration.packages)您可以分别使用`@EnableMongoRepositories`和`@EntityScan`自定义查找存储库和文档的位置。

> 有关 Spring Data MongoDB 的完整详细信息，包括其丰富的对象映射技术，请参阅其[参考文档](https://spring.io/projects/spring-data-mongodb)。

**9.2.3. Neo4j**

[Neo4j](https://neo4j.com/)是一个开源 NoSQL 图形数据库，它使用通过一流关系连接的丰富节点数据模型，比传统 RDBMS 方法更适合互联大数据。Spring Boot 为使用 Neo4j 提供了多种便利，包括`spring-boot-starter-data-neo4j`“Starter”。

**连接到 Neo4j 数据库**

要访问 Neo4j 服务器，您可以注入自动配置的`org.neo4j.driver.Driver`. 默认情况下，实例尝试使用 Bolt 协议连接到 Neo4j 服务器`localhost:7687`。以下示例展示了如何注入 Neo4j `Driver`，该 Neo4j 使您可以访问 `Session`等内容：

```
@Component
public class MyBean {
​
    private final Driver driver;
​
    public MyBean(Driver driver) {
        this.driver = driver;
    }
​
    // ...
​
}
```

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

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

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

**Spring Data Neo4j 存储库**

Spring Data 包括对 Neo4j 的存储库支持。有关 Spring Data Neo4j 的完整详细信息，请参阅[参考文档](https://docs.spring.io/spring-data/neo4j/docs/7.2.0/reference/html/)。

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

```
public interface CityRepository extends Neo4jRepository<City, Long> {
​
    Optional<City> findOneByNameAndState(String name, String state);
​
}
```

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

通过扫描找到存储库和实体。默认情况下，扫描[自动配置包。](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using.auto-configuration.packages)您可以分别使用`@EnableNeo4jRepositories`和`@EntityScan`自定义查找存储库和实体的位置。

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

```
@Configuration(proxyBeanMethods = false)
public class MyNeo4jConfiguration {
​
    @Bean
    public ReactiveNeo4jTransactionManager reactiveTransactionManager(Driver driver,
            ReactiveDatabaseSelectionProvider databaseNameProvider) {
        return new ReactiveNeo4jTransactionManager(driver, databaseNameProvider);
    }
​
}
```

**9.2.4. Elasticsearch**

[Elasticsearch](https://www.elastic.co/products/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`模块中的[低级客户端](https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/java-rest-low.html)和`co.elastic.clients:elasticsearch-java`模块中的[Java API 客户端](https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/index.html)。此外，Spring Boot 还为`org.springframework.data:spring-data-elasticsearch`模块中的响应式客户端提供支持。默认情况下，客户端将定位`localhost:9200`. 您可以使用`spring.elasticsearch.*`属性来进一步调整客户端的配置方式，如以下示例所示：

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

**使用 RestClient 连接到 Elasticsearch**

如果您在类路径上含有`elasticsearch-rest-client`，Spring Boot 将自动配置并注册一个`RestClient`bean。除了前面描述的属性之外，要进行`RestClient`微调，您还可以注册任意数量的 Bean 以实现`RestClientBuilderCustomizer`更高级的自定义。要完全控制客户端的配置，请定义一个`RestClientBuilder`bean。

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

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

**使用 ElasticsearchClient 连接到 Elasticsearch**

如果`co.elastic.clients:elasticsearch-java`位于类路径上，Spring Boot 将自动配置并注册一个`ElasticsearchClient`bean。

`ElasticsearchClient`使用的传输取决于前面描述的`RestClient`。因此，前面描述的属性可用于配置`ElasticsearchClient`. 此外，您可以定义一个`RestClientOptions`bean 来进一步控制传输的行为。

**使用 ReactiveElasticsearchClient 连接到 Elasticsearch**

[Spring Data Elasticsearch](https://spring.io/projects/spring-data-elasticsearch)用于`ReactiveElasticsearchClient`以反应方式查询 Elasticsearch 实例。如果类路径上有 Spring Data Elasticsearch 和 Reactor，Spring Boot 将自动配置并注册一个`ReactiveElasticsearchClient`.

`ReactiveElasticsearchclient`使用的传输取决于前面描述的`RestClient`。因此，前面描述的属性可用于配置`ReactiveElasticsearchClient`. 此外，您可以定义一个`RestClientOptions`bean 来进一步控制传输的行为。

**使用 Spring Data 连接到 Elasticsearch**

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

```
@Component
public class MyBean {
​
    private final ElasticsearchTemplate template;
​
    public MyBean(ElasticsearchTemplate template) {
        this.template = template;
    }
​
    // ...
​
}
```

在存在`spring-data-elasticsearch`和Reactor的情况下，Spring Boot 还可以自动配置[ReactiveElasticsearchClient](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#data.nosql.elasticsearch.connecting-using-rest.reactiveclient)和`ReactiveElasticsearchTemplate` beans。它们是其他 REST 客户端的响应式等价物。

**Spring Data Elasticsearch 存储库**

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

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

通过扫描找到存储库和文档。默认情况下，扫描[自动配置包。](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using.auto-configuration.packages)您可以分别使用`@EnableElasticsearchRepositories`和`@EntityScan`自定义查找存储库和文档的位置。

> 有关 Spring Data Elasticsearch 的完整详细信息，请参阅[参考文档](https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/)。

Spring Boot 使用`ElasticsearchRestTemplate`或`ReactiveElasticsearchTemplate`beans支持经典和反应式 Elasticsearch 存储库。如果存在所需的依赖项，这些 bean 很可能是由 Spring Boot 自动配置的。

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

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

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

**9.2.5. Cassandra**

[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”可以方便地收集依赖项。

**连接到卡桑德拉**

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

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

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

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

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

通过设置属性，可以将自动配置`CqlSession`配置为使用 SSL 与服务器进行通信，如下例所示：

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

[可以在SSL 捆绑包](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#features.ssl)中配置自定义 SSL 信任材料并将其应用到`CqlSession`以下示例中：

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

> Cassandra 驱动程序有自己的配置基础架构，可在类路径的根目录加载 `application.conf`。
>
> Spring Boot 默认情况下不会查找此类文件，但可以使用`spring.cassandra.config`加载该文件。如果某个属性同时存在于 `spring.cassandra.*` 和配置文件中，则 `spring.cassandra.*`中的值优先。
>
> 对于更高级的驱动程序自定义，您可以注册任意数量的实现`DriverConfigLoaderBuilderCustomizer` 的 bean。可以使用 `CqlSessionBuilderCustomizer` 类型的 bean 来自定义 CqlSession。
>
> 如果您用来`CqlSessionBuilder`创建多个`CqlSession`bean，请记住构建器是可变的，因此请确保为每个会话注入一个新的副本。

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

```
@Component
public class MyBean {
​
    private final CassandraTemplate template;
​
    public MyBean(CassandraTemplate template) {
        this.template = template;
    }
​
    // ...
​
}
```

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

**Spring Data Cassandra 存储库**

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

通过扫描找到存储库和实体。默认情况下，扫描[自动配置包。](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using.auto-configuration.packages)您可以分别使用`@EnableCassandraRepositories`和`@EntityScan`自定义查找存储库和实体的位置。

> 有关 Spring Data Cassandra 的完整详细信息，请参阅[参考文档](https://docs.spring.io/spring-data/cassandra/docs/)。

**9.2.6. 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`Starters `spring-boot-starter-data-couchbase-reactive`”可以方便地收集依赖项。

**连接到 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
```

还可以自定义一些设置`ClusterEnvironment`。例如，以下配置更改打开新`Bucket`的超时时间并通过引用已配置的[SSL 捆绑包](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#features.ssl)启用 SSL 支持：

```
spring.couchbase.env.timeouts.connect=3s
spring.couchbase.env.ssl.bundle=example
```

> 检查`spring.couchbase.env.*`属性以获取更多详细信息。为了更好地控制，可以使用一种或多种`ClusterEnvironmentBuilderCustomizer`bean。

**Spring Data Couchbase 存储库**

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

通过扫描找到存储库和文档。默认情况下，扫描[自动配置包。](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using.auto-configuration.packages)您可以分别使用`@EnableCouchbaseRepositories`和`@EntityScan`自定义查找存储库和文档的位置。

有关 Spring Data Couchbase 的完整详细信息，请参阅[参考文档](https://docs.spring.io/spring-data/couchbase/docs/5.2.0/reference/html/)。

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

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

以下示例展示了如何注入`CouchbaseTemplate`Bean：

```
@Component
public class MyBean {
​
    private final CouchbaseTemplate template;
​
    public MyBean(CouchbaseTemplate template) {
        this.template = template;
    }
​
    // ...
​
}
```

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

* 名字为`couchbaseMappingContext`的`CouchbaseMappingContext` `@Bean`.
* 名字为`couchbaseCustomConversions`的`CustomConversions` `@Bean`
* 名字为`couchbaseTemplate`的`CouchbaseTemplate` `@Bean`

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

```
@Configuration(proxyBeanMethods = false)
public class MyCouchbaseConfiguration {
​
    @Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
    public CouchbaseCustomConversions myCustomConversions() {
        return new CouchbaseCustomConversions(Arrays.asList(new MyConverter()));
    }
​
}
```

**9.2.7. LDAP**

[LDAP](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol)（轻量级目录访问协议）是一种开放的、供应商中立的行业标准应用协议，用于通过 IP 网络访问和维护分布式目录信息服务。Spring Boot 为任何兼容的 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”可以方便地收集依赖项。

**连接到 LDAP 服务器**

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

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

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

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

**Spring Data LDAP 存储库**

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

通过扫描找到存储库和文档。默认情况下，扫描[自动配置包。](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using.auto-configuration.packages)您可以分别使用`@EnableLdapRepositories`和`@EntityScan`自定义查找存储库和文档的位置。

有关 Spring Data LDAP 的完整详细信息，请参阅[参考文档](https://docs.spring.io/spring-data/ldap/docs/1.0.x/reference/html/)。

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

```
@Component
public class MyBean {
​
    private final LdapTemplate template;
​
    public MyBean(LdapTemplate template) {
        this.template = template;
    }
​
    // ...
​
}
```

**嵌入式内存 LDAP 服务器**

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

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

可以定义多个基本 dn 值，但是，由于可分辨名称通常包含逗号，因此必须使用正确的符号来定义它们。在 yaml 文件中，您可以使用 yaml 列表表示法。在属性文件中，您必须包含索引作为属性名称的一部分：

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

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

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

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

**9.2.8. InfluxDB**

> InfluxDB 的自动配置已被弃用，并计划在 Spring Boot 3.4 中删除，以支持提供自己的 Spring Boot 集成的 [新 InfluxDB Java 客户端。](https://github.com/influxdata/influxdb-client-java)

[InfluxDB](https://www.influxdata.com/)是一款开源时间序列数据库，专为操作监控、应用程序指标、物联网传感器数据和实时分析等领域的时间序列数据的快速、高可用性存储和检索而优化。

**连接到 InfluxDB**

Spring Boot 会自动配置一个`InfluxDB`实例，前提是`influxdb-java`客户端位于类路径上并且数据库的 URL 使用`spring.influx.url`设置.

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

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

如果您需要对配置进行更多控制，请考虑注册`InfluxDbCustomizer`bean。