跳到主要内容

使用 NoSQL 技术

DeepSeek V3 中英对照 Working with NoSQL Technologies

使用 NoSQL 技术​

Spring Data 提供了额外的项目，帮助您访问各种 NoSQL 技术，包括：

其中，Spring Boot 为 Cassandra、Couchbase、Elasticsearch、LDAP、MongoDB、Neo4J 和 Redis 提供了自动配置。此外，Spring Boot for Apache Geode 提供了 Apache Geode 的自动配置。你可以使用其他项目，但必须自行配置它们。请参阅 spring.io/projects/spring-data 上的相应参考文档。

Spring Boot 也为 InfluxDB 客户端提供了自动配置，但该功能已被弃用，取而代之的是新的 InfluxDB Java 客户端，它提供了自己的 Spring Boot 集成。

Redis​

Redis 是一种缓存、消息代理和功能丰富的键值存储。Spring Boot 为 Lettuce 和 Jedis 客户端库以及 Spring Data Redis 提供的抽象层提供了基本的自动配置。

为了方便地收集依赖项，有一个 spring-boot-starter-data-redis starter。默认情况下，它使用 Lettuce。这个 starter 同时支持传统和响应式应用。

提示

为了与其他支持响应式的存储保持一致，我们还提供了 spring-boot-starter-data-redis-reactive 启动器。

连接到 Redis​

你可以像注入其他 Spring Bean 一样，注入自动配置的 RedisConnectionFactory、StringRedisTemplate 或原生的 RedisTemplate 实例。以下代码展示了一个这样的 Bean 示例：

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final StringRedisTemplate template;

    public MyBean(StringRedisTemplate template) {
        this.template = template;
    }

    // ...

    public Boolean someMethod() {
        return this.template.hasKey("spring");
    }

}
java

默认情况下，实例会尝试连接位于 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
properties

你也可以直接指定 Redis 服务器的 URL。当设置了 URL 时，host、port、username 和 password 属性将被忽略。如下例所示：

spring.data.redis.url=redis://user:secret@localhost:6379
spring.data.redis.database=0
properties
提示

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

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

默认情况下，如果类路径中包含 commons-pool2，则会自动配置一个池化连接工厂。

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

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

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

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

MongoDB​

MongoDB 是一个开源的 NoSQL 文档数据库，它使用类似 JSON 的模式，而不是传统的基于表的关系数据。Spring Boot 为使用 MongoDB 提供了多种便利，包括 spring-boot-starter-data-mongodb 和 spring-boot-starter-data-mongodb-reactive 启动器。

连接到 MongoDB 数据库​

要访问 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");
    }

}
java

如果你已经定义了自己的 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
properties

或者，您可以使用离散属性来指定连接详细信息。例如，您可以在 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
properties

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

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

自定义 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
properties
提示

如果未指定 spring.data.mongodb.port，则默认使用 27017。你可以从前面的示例中删除这一行。

你也可以通过使用 host:port 语法将端口作为主机地址的一部分来指定。如果你需要更改 additional-hosts 条目的端口，则应使用此格式。

提示

如果你不使用 Spring Data MongoDB，你可以注入一个 MongoClient bean 来代替使用 MongoDatabaseFactory。如果你想完全控制建立 MongoDB 连接，你也可以声明你自己的 MongoDatabaseFactory 或 MongoClient bean。

备注

如果你正在使用响应式驱动，SSL 需要依赖 Netty。如果 Netty 可用且工厂尚未自定义，自动配置将自动配置此工厂。

MongoTemplate​

Spring Data MongoDB 提供了一个 MongoTemplate 类，其设计与 Spring 的 JdbcTemplate 非常相似。与 JdbcTemplate 一样，Spring Boot 会自动配置一个 bean，以便你注入该模板，如下所示：

import com.mongodb.client.MongoCollection;
import org.bson.Document;

import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final MongoTemplate mongoTemplate;

    public MyBean(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    // ...

    public MongoCollection<Document> someMethod() {
        return this.mongoTemplate.getCollection("users");
    }

}
java

有关完整详情，请参阅 MongoOperations API 文档。

Spring Data MongoDB 仓库​

Spring Data 包含了对 MongoDB 的仓库支持。与之前讨论的 JPA 仓库类似，其基本原理是根据方法名自动构建查询。

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

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.Repository;

public interface CityRepository extends Repository<City, Long> {

    Page<City> findAll(Pageable pageable);

    City findByNameAndStateAllIgnoringCase(String name, String state);

}
java

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

提示

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

Neo4j​

Neo4j 是一个开源的 NoSQL 图数据库，它使用了一种丰富的节点数据模型，这些节点通过一级关系相互连接，这使得它比传统的 RDBMS 方法更适合处理连接的大数据。Spring Boot 提供了多种便利来与 Neo4j 协同工作，包括 spring-boot-starter-data-neo4j 启动器。

连接到 Neo4j 数据库​

要访问 Neo4j 服务器，你可以注入一个自动配置的 Driver。默认情况下，实例会尝试使用 Bolt 协议连接到 localhost:7687 的 Neo4j 服务器。以下示例展示了如何注入 Neo4j Driver，通过它可以访问 Session 等功能：

import org.neo4j.driver.Driver;
import org.neo4j.driver.Session;
import org.neo4j.driver.Values;

import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final Driver driver;

    public MyBean(Driver driver) {
        this.driver = driver;
    }

    // ...

    public String someMethod(String message) {
        try (Session session = this.driver.session()) {
            return session.executeWrite(
                    (transaction) -> transaction
                        .run("CREATE (a:Greeting) SET a.message = $message RETURN a.message + ', from node ' + id(a)",
                                Values.parameters("message", message))
                        .single()
                        .get(0)
                        .asString());
        }
    }

}
java

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

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

自动配置的 Driver 是使用 org.neo4j.driver.Config$ConfigBuilder 创建的。为了微调其配置，可以声明一个或多个 ConfigBuilderCustomizer Bean。每个 Bean 都会按照顺序被调用，并传入用于构建 Driver 的 org.neo4j.driver.Config$ConfigBuilder。

Spring Data Neo4j 仓库​

Spring Data 包含对 Neo4j 的仓库支持。有关 Spring Data Neo4j 的完整详细信息，请参阅参考文档。

Spring Data Neo4j 与 Spring Data JPA 共享了与其他许多 Spring Data 模块相同的基础设施。你可以从之前的 JPA 示例中获取灵感，将 City 定义为 Spring Data Neo4j 的 @Node 而不是 JPA 的 @Entity，其仓库抽象的工作方式也相同，如下例所示：

import java.util.Optional;

import org.springframework.data.neo4j.repository.Neo4jRepository;

public interface CityRepository extends Neo4jRepository<City, Long> {

    Optional<City> findOneByNameAndState(String name, String state);

}
java

spring-boot-starter-data-neo4j starter 启用了仓库支持以及事务管理。Spring Boot 支持经典和响应式的 Neo4j 仓库，使用 Neo4jTemplate 或 ReactiveNeo4jTemplate bean。当 Project Reactor 在类路径上可用时，响应式风格也会自动配置。

存储库和实体是通过扫描找到的。默认情况下，会扫描自动配置包。你可以通过使用 @EnableNeo4jRepositories 和 @EntityScan 分别自定义查找存储库和实体的位置。

备注

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

import org.neo4j.driver.Driver;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider;
import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager;

@Configuration(proxyBeanMethods = false)
public class MyNeo4jConfiguration {

    @Bean
    public ReactiveNeo4jTransactionManager reactiveTransactionManager(Driver driver,
            ReactiveDatabaseSelectionProvider databaseNameProvider) {
        return new ReactiveNeo4jTransactionManager(driver, databaseNameProvider);
    }

}
java

Elasticsearch​

Elasticsearch 是一个开源的、分布式的、RESTful 风格的搜索和分析引擎。Spring Boot 为 Elasticsearch 客户端提供了基本的自动配置功能。

Spring Boot 支持多种客户端：

Spring Boot 提供了一个专用的启动器，spring-boot-starter-data-elasticsearch。

使用 REST 客户端连接 Elasticsearch​

Elasticsearch 提供了两种不同的 REST 客户端，供你用于查询集群：来自 org.elasticsearch.client:elasticsearch-rest-client 模块的低级客户端，以及来自 co.elastic.clients:elasticsearch-java 模块的 Java API 客户端。此外，Spring Boot 还提供了对 org.springframework.data:spring-data-elasticsearch 模块中反应式客户端的支持。默认情况下，这些客户端将指向 [localhost:9200](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
properties

使用 RestClient 连接 Elasticsearch​

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

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

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

使用 ElasticsearchClient 连接 Elasticsearch​

如果你在类路径中有 co.elastic.clients:elasticsearch-java，Spring Boot 将自动配置并注册一个 ElasticsearchClient bean。

ElasticsearchClient 使用了一个依赖于之前描述的 RestClient 的传输层。因此，之前描述的属性可以用来配置 ElasticsearchClient。此外，你可以定义一个 RestClientOptions bean 来进一步控制传输层的行为。

使用 ReactiveElasticsearchClient 连接 Elasticsearch​

Spring Data Elasticsearch 提供了 ReactiveElasticsearchClient，用于以响应式的方式查询 Elasticsearch 实例。如果你的项目依赖中包含了 Spring Data Elasticsearch 和 Reactor，Spring Boot 会自动配置并注册一个 ReactiveElasticsearchClient。

ReactiveElasticsearchClient 使用依赖于之前描述的 RestClient 的传输层。因此，之前描述的属性可以用来配置 ReactiveElasticsearchClient。此外，你可以定义一个 RestClientOptions 的 Bean 来进一步控制传输层的行为。

使用 Spring Data 连接 Elasticsearch​

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

import org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final ElasticsearchTemplate template;

    public MyBean(ElasticsearchTemplate template) {
        this.template = template;
    }

    // ...

    public boolean someMethod(String id) {
        return this.template.exists(id, User.class);
    }

}
java

在同时存在 spring-data-elasticsearch 和 Reactor 的情况下，Spring Boot 还可以自动配置 ReactiveElasticsearchClient 和 ReactiveElasticsearchTemplate 作为 Bean。它们是其他 REST 客户端的响应式等价物。

Spring Data Elasticsearch 仓库​

Spring Data 包含对 Elasticsearch 的仓库支持。与之前讨论的 JPA 仓库类似，其基本原理是基于方法名自动为你构建查询。

事实上，Spring Data JPA 和 Spring Data Elasticsearch 共享相同的基础设施。你可以拿之前的 JPA 示例来说明，假设 City 现在是一个 Elasticsearch @Document 类，而不是一个 JPA @Entity，它们的工作方式是相同的。

通过扫描可以找到存储库和文档。默认情况下，会扫描自动配置包。你可以通过使用 @EnableElasticsearchRepositories 和 @EntityScan 分别自定义查找存储库和文档的位置。

提示

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

Spring Boot 支持经典和响应式的 Elasticsearch 仓库，使用 ElasticsearchTemplate 或 ReactiveElasticsearchTemplate Bean。在所需的依赖项存在的情况下，这些 Bean 很可能由 Spring Boot 自动配置。

如果你想使用自己的模板来支持 Elasticsearch 仓库，你可以添加自己的 ElasticsearchTemplate 或 ElasticsearchOperations @Bean，只要将其命名为 "elasticsearchTemplate" 即可。同样适用于 ReactiveElasticsearchTemplate 和 ReactiveElasticsearchOperations，其 Bean 名称为 "reactiveElasticsearchTemplate"。

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

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

Cassandra​

Cassandra 是一个开源的分布式数据库管理系统，旨在处理跨多台普通服务器的大量数据。Spring Boot 提供了对 Cassandra 的自动配置，以及由 Spring Data Cassandra 在其基础上提供的抽象。spring-boot-starter-data-cassandra 启动器可以方便地收集依赖项。

连接到 Cassandra​

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

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

如果所有联系点的端口相同，您可以使用简写方式，仅指定主机名，如下例所示：

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

这两个示例是相同的，因为端口默认为 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
properties

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

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

Cassandra 驱动程序拥有自己的配置基础设施，它会在类路径的根目录下加载一个 application.conf 文件。

Spring Boot 默认不会寻找这样的文件，但可以通过使用 spring.cassandra.config 加载一个。如果某个属性同时存在于 spring.cassandra.* 和配置文件中，spring.cassandra.* 中的值将优先。

对于更高级的驱动程序定制，你可以注册任意数量的实现 DriverConfigLoaderBuilderCustomizer 的 bean。CqlSession 可以通过类型为 CqlSessionBuilderCustomizer 的 bean 进行定制。

备注

如果你使用 CqlSessionBuilder 创建多个 CqlSession bean，请注意该构建器是可变的，因此请确保为每个会话注入一个新的副本。

以下代码清单展示了如何注入一个 Cassandra bean：

import org.springframework.data.cassandra.core.CassandraTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final CassandraTemplate template;

    public MyBean(CassandraTemplate template) {
        this.template = template;
    }

    // ...

    public long someMethod() {
        return this.template.count(User.class);
    }

}
java

如果你添加了自己类型的 @Bean 为 CassandraTemplate，它会替换默认的配置。

Spring Data Cassandra 仓库​

Spring Data 包含对 Cassandra 的基本仓库支持。目前，这比前面讨论的 JPA 仓库更加有限，并且需要使用 @Query 注解的查找方法。

通过扫描可以找到仓库和实体。默认情况下，会扫描自动配置包。你可以分别使用 @EnableCassandraRepositories 和 @EntityScan 来自定义查找仓库和实体的位置。

提示

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

Couchbase​

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

连接到 Couchbase​

你可以通过添加 Couchbase SDK 和一些配置来获取一个 Cluster。spring.couchbase.* 属性可以用来自定义连接。通常，你需要提供连接字符串和用于认证的凭据。以下示例展示了如何配置用户名和密码的基础认证：

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

客户端证书 可以用于认证，代替用户名和密码。包含客户端证书的 Java 密钥库的位置和密码可以按照以下示例进行配置：

spring.couchbase.connection-string=couchbase://192.168.1.123
spring.couchbase.env.ssl.enabled=true
spring.couchbase.authentication.jks.location=classpath:client.p12
spring.couchbase.authentication.jks.password=secret
properties

PEM 编码的证书和私钥可以按照以下示例进行配置：

spring.couchbase.connection-string=couchbase://192.168.1.123
spring.couchbase.env.ssl.enabled=true
spring.couchbase.authentication.pem.certificates=classpath:client.crt
spring.couchbase.authentication.pem.private-key=classpath:client.key
properties

也可以自定义一些 ClusterEnvironment 的设置。例如，以下配置将打开新 Bucket 的超时时间进行了修改，并通过引用配置好的 SSL 包 启用了 SSL 支持：

spring.couchbase.env.timeouts.connect=3s
spring.couchbase.env.ssl.bundle=example
properties
提示

有关更多详细信息，请查看 spring.couchbase.env.* 属性。为了获得更多控制，可以使用一个或多个 ClusterEnvironmentBuilderCustomizer 类型的 Bean。

Spring Data Couchbase 仓库​

Spring Data 包含对 Couchbase 的仓库支持。

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

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

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

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

以下示例展示了如何注入一个 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();
    }

}
java

你可以在自己的配置中定义一些 bean 来覆盖自动配置提供的默认实现：

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

import org.assertj.core.util.Arrays;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.couchbase.config.BeanNames;
import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions;

@Configuration(proxyBeanMethods = false)
public class MyCouchbaseConfiguration {

    @Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
    public CouchbaseCustomConversions myCustomConversions() {
        return new CouchbaseCustomConversions(Arrays.asList(new MyConverter()));
    }

}
java

LDAP​

LDAP（轻量级目录访问协议）是一种开放的、厂商中立的行业标准应用协议，用于通过 IP 网络访问和维护分布式目录信息服务。Spring Boot 提供了对任何兼容的 LDAP 服务器的自动配置，以及对来自 UnboundID 的嵌入式内存 LDAP 服务器的支持。

LDAP 抽象由 Spring Data LDAP 提供。为了方便地收集依赖，有一个 spring-boot-starter-data-ldap starter。

连接到 LDAP 服务器​

要连接到 LDAP 服务器，请确保声明对 spring-boot-starter-data-ldap 启动器或 spring-ldap-core 的依赖，然后在 application.properties 中声明服务器的 URL，如下例所示：

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

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

基于这些设置，LdapContextSource 会被自动配置。如果存在 DirContextAuthenticationStrategy bean，它将会与自动配置的 LdapContextSource 关联。如果你需要对其进行自定义，例如使用 PooledContextSource，你仍然可以注入自动配置的 LdapContextSource。请确保将你自定义的 ContextSource 标记为 @Primary，以便自动配置的 LdapTemplate 使用它。

Spring Data LDAP 仓库​

Spring Data 包含对 LDAP 的仓库支持。

存储库和文档通过扫描被发现。默认情况下，会扫描自动配置包。你可以分别使用 @EnableLdapRepositories 和 @EntityScan 来自定义查找存储库和文档的位置。

提示

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

你也可以像注入其他 Spring Bean 一样注入一个自动配置的 LdapTemplate 实例，如下例所示：

import java.util.List;

import org.springframework.ldap.core.LdapTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final LdapTemplate template;

    public MyBean(LdapTemplate template) {
        this.template = template;
    }

    // ...

    public List<User> someMethod() {
        return this.template.findAll(User.class);
    }

}
java

嵌入式内存 LDAP 服务器​

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

spring.ldap.embedded.base-dn=dc=spring,dc=io
properties
备注

可以定义多个 base-dn 值，但由于专有名称（distinguished names）通常包含逗号，因此必须使用正确的符号来定义。

在 YAML 文件中，可以使用 YAML 列表符号。在 properties 文件中，必须将索引作为属性名称的一部分：

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

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

如果你的 classpath 上有一个 schema.ldif 文件，它将被用来初始化服务器。如果你想从不同的资源加载初始化脚本，你也可以使用 spring.ldap.embedded.ldif 属性。

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