# 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。


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://doc.shiker.tech/spring-boot-can-kao-wen-dang/9.-shu-ju/9.2.-shi-yong-nosql-ji-shu.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.