此版本仍在开发中，尚未被视为稳定版本。如需最新稳定版本，请使用 Spring Boot 4.0.4!spring-doc.cadn.net.cn

使用 NoSQL 技术

Spring Data 提供了其他项目，帮助您访问多种 NoSQL 技术，包括：spring-doc.cadn.net.cn

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

Spring Boot 也提供了对 InfluxDB 客户端的自动配置，但该功能已被弃用，推荐改用 新的 InfluxDB Java 客户端，该客户端自身已提供 Spring Boot 集成支持。spring-doc.cadn.net.cn

Redis

Redis 是一种缓存、消息代理以及功能丰富的键值存储系统。 Spring Boot 为 Lettuce 和 Jedis 客户端库，以及 Spring Data Redis 提供的上层抽象提供了基本的自动配置支持。spring-doc.cadn.net.cn

有一个 spring-boot-starter-data-redis Starters，可方便地收集依赖项。 默认情况下，它使用 Lettuce。 该Starters同时支持传统应用和响应式应用。spring-doc.cadn.net.cn

我们还提供一个 spring-boot-starter-data-redis-reactive Starters，以确保与其他支持响应式编程的存储库保持一致。

连接到 Redis

您可以像注入其他任何 Spring Bean 一样，注入一个已自动配置的 RedisConnectionFactory、StringRedisTemplate 或标准的 RedisTemplate 实例。 以下示例展示了此类 Bean 的用法：spring-doc.cadn.net.cn

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

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

@Component
class MyBean(private val template: StringRedisTemplate) {

	// ...

	fun someMethod(): Boolean {
		return template.hasKey("spring")
	}

}

默认情况下，该实例会尝试连接到位于 localhost:6379 的 Redis 服务器。 您可以通过 spring.data.redis.* 属性指定自定义连接信息，如下例所示：spring-doc.cadn.net.cn

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
spring:
  data:
    redis:
      host: "localhost"
      port: 6379
      database: 0
      username: "user"
      password: "secret"

您还可以直接指定 Redis 服务器的 URL。 设置 URL 时，host、port、username 和 password 属性将被忽略。 以下示例展示了该用法：spring-doc.cadn.net.cn

spring.data.redis.url=redis://user:secret@localhost:6379
spring.data.redis.database=0
spring:
  data:
    redis:
      url: "redis://user:secret@localhost:6379"
      database: 0
您还可以注册任意数量的、实现 LettuceClientConfigurationBuilderCustomizer 接口的 Bean，以支持更高级的自定义配置。 ClientResources 也可通过 ClientResourcesBuilderCustomizer 进行自定义。 如果您使用 Jedis，则还可使用 JedisClientConfigurationBuilderCustomizer。 或者，您也可以注册类型为 RedisStandaloneConfiguration、RedisSentinelConfiguration 或 RedisClusterConfiguration 的 Bean，从而对配置进行完全控制。

如果您为任意一种自动配置的类型添加了自己的 @Bean，它将取代默认配置（RedisTemplate 除外，此时排除依据是 Bean 名称 redisTemplate，而非其类型）。spring-doc.cadn.net.cn

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

自动配置的 RedisConnectionFactory 可通过设置如下示例所示的属性，配置为使用 SSL 与服务器进行通信：spring-doc.cadn.net.cn

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

自定义 SSL 信任材料可在 SSL 绑定包 中进行配置，并应用于 RedisConnectionFactory，如下例所示：spring-doc.cadn.net.cn

spring.data.redis.ssl.bundle=example
spring:
  data:
    redis:
      ssl:
        bundle: "example"

MongoDB

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

连接到 MongoDB 数据库

要访问 MongoDB 数据库，您可以注入一个自动配置的 MongoDatabaseFactory。 默认情况下，该实例会尝试连接到位于 mongodb://localhost/test 的 MongoDB 服务器。 以下示例展示了如何连接到 MongoDB 数据库：spring-doc.cadn.net.cn

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

}
import com.mongodb.client.MongoCollection
import org.bson.Document
import org.springframework.data.mongodb.MongoDatabaseFactory
import org.springframework.stereotype.Component

@Component
class MyBean(private val mongo: MongoDatabaseFactory) {

	// ...

	fun someMethod(): MongoCollection<Document> {
		val db = mongo.mongoDatabase
		return db.getCollection("users")
	}

}

如果您已定义了自己的 MongoClient，则将使用它来自动配置一个合适的 MongoDatabaseFactory。spring-doc.cadn.net.cn

自动配置的 MongoClient 是使用 MongoClientSettings Bean 创建的。 如果您已定义了自己的 MongoClientSettings，则该 Bean 将未经修改直接使用，而 spring.data.mongodb 属性将被忽略。 否则，将自动配置一个 MongoClientSettings，并将其应用 spring.data.mongodb 属性。 无论哪种情况，您均可声明一个或多个 MongoClientSettingsBuilderCustomizer Bean，以微调 MongoClientSettings 的配置。 每个 Bean 将按顺序被调用，并传入用于构建 MongoClientSettings 的 MongoClientSettings.Builder。spring-doc.cadn.net.cn

您可以设置 spring.data.mongodb.uri 属性来更改 URL，并配置其他设置（例如 副本集），如下例所示：spring-doc.cadn.net.cn

spring.data.mongodb.uri=mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test
spring:
  data:
    mongodb:
      uri: "mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test"

或者，您也可以使用独立的属性来指定连接详细信息。 例如，您可以在 application.properties 中声明以下设置：spring-doc.cadn.net.cn

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
spring:
  data:
    mongodb:
      host: "mongoserver1.example.com"
      port: 27017
      additional-hosts:
      - "mongoserver2.example.com:23456"
      database: "test"
      username: "user"
      password: "secret"

自动配置的 MongoClient 可通过设置如下示例所示的属性，配置为使用 SSL 与服务器进行通信：spring-doc.cadn.net.cn

spring.data.mongodb.uri=mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test
spring.data.mongodb.ssl.enabled=true
spring:
  data:
    mongodb:
      uri: "mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test"
      ssl:
        enabled: true

自定义 SSL 信任材料可在 SSL 绑定包 中进行配置，并应用于 MongoClient，如下例所示：spring-doc.cadn.net.cn

spring.data.mongodb.uri=mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test
spring.data.mongodb.ssl.bundle=example
spring:
  data:
    mongodb:
      uri: "mongodb://user:[email protected]:27017,mongoserver2.example.com:23456/test"
      ssl:
        bundle: "example"

如果不指定 spring.data.mongodb.port，则使用默认值 27017。 您可以从前面示例中删除此行。spring-doc.cadn.net.cn

您还可以通过使用 host:port 语法，在主机地址中指定端口号。 如果需要更改某个 additional-hosts 条目的端口，则应采用此格式。spring-doc.cadn.net.cn
如果不使用 Spring Data MongoDB，您可以注入一个 MongoClient Bean，而非使用 MongoDatabaseFactory。 如果希望完全控制 MongoDB 连接的建立过程，您还可以自行声明 MongoDatabaseFactory 或 MongoClient Bean。
如果使用响应式驱动程序，则需要 Netty 来支持 SSL。 当 Netty 可用且尚未自定义要使用的工厂时，自动配置会自动配置该工厂。

MongoTemplate

Spring Data MongoDB 提供了一个 MongoTemplate 类，其设计与 Spring 的 JdbcTemplate 非常相似。 与 JdbcTemplate 一样，Spring Boot 会自动为您配置一个 Bean，以便您注入该模板，如下所示：spring-doc.cadn.net.cn

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

}
import com.mongodb.client.MongoCollection
import org.bson.Document
import org.springframework.data.mongodb.core.MongoTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val mongoTemplate: MongoTemplate) {

	// ...

	fun someMethod(): MongoCollection<Document> {
		return mongoTemplate.getCollection("users")
	}

}

请参阅 MongoOperations 的 API 文档以了解完整详情。spring-doc.cadn.net.cn

Spring Data MongoDB 仓库

Spring Data 包含对 MongoDB 的仓库支持。 与前面讨论的 JPA 仓库一样，其基本原理是：查询会根据方法名称自动构建。spring-doc.cadn.net.cn

事实上，Spring Data JPA 和 Spring Data MongoDB 共享相同的通用基础设施。 您可以采用前面的 JPA 示例，并假设 City 现在是一个 MongoDB 数据类，而非 JPA @Entity，它将以相同的方式运行，如下例所示：spring-doc.cadn.net.cn

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);

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

interface CityRepository :
	Repository<City?, Long?> {
	fun findAll(pageable: Pageable?): Page<City?>?
	fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): City?
}

通过扫描查找仓库和文档。 默认情况下，将扫描自动配置包。 您可分别使用@EnableMongoRepositories和@EntityScan来自定义查找仓库和文档的位置。spring-doc.cadn.net.cn

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

Neo4j

Neo4j 是一款开源的 NoSQL 图数据库，采用丰富的数据模型，其中节点通过一等关系相互连接；相较于传统的 RDBMS 方法，该模型更适用于处理关联性更强的大数据。 Spring Boot 为 Neo4j 提供了多项使用便利，包括 spring-boot-starter-data-neo4j Starters。spring-doc.cadn.net.cn

连接到 Neo4j 数据库

要访问 Neo4j 服务器，您可以注入一个已自动配置的 Driver。 默认情况下，该实例会尝试使用 Bolt 协议连接至位于 localhost:7687 的 Neo4j 服务器。 以下示例展示了如何注入一个 Neo4j Driver，它可为您提供对多种组件（包括 Session）的访问能力：spring-doc.cadn.net.cn

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());
		}
	}

}
import org.neo4j.driver.Driver
import org.neo4j.driver.TransactionContext
import org.neo4j.driver.Values
import org.springframework.stereotype.Component

@Component
class MyBean(private val driver: Driver) {
	// ...
	fun someMethod(message: String?): String {
		driver.session().use { session ->
			return@someMethod session.executeWrite { transaction: TransactionContext ->
				transaction
					.run(
						"CREATE (a:Greeting) SET a.message = \$message RETURN a.message + ', from node ' + id(a)",
						Values.parameters("message", message)
					)
					.single()[0].asString()
			}
		}
	}
}

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

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

自动配置的 Driver 是使用 org.neo4j.driver.Config$ConfigBuilder 创建的。 若要微调其配置，请声明一个或多个 ConfigBuilderCustomizer Bean。 每个 Bean 将按顺序被调用，并传入用于构建 Driver 的 org.neo4j.driver.Config$ConfigBuilder。spring-doc.cadn.net.cn

Spring Data Neo4j 仓库

Spring Data 包含对 Neo4j 的仓库支持。 有关 Spring Data Neo4j 的完整详细信息，请参阅 参考文档。spring-doc.cadn.net.cn

Spring Data Neo4j 与其他许多 Spring Data 模块一样，与 Spring Data JPA 共享通用的基础架构。 您可以采用前面的 JPA 示例，并将 City 定义为 Spring Data Neo4j 的 @Node，而非 JPA 的 @Entity；此时，仓库（Repository）抽象的工作方式保持不变，如下例所示：spring-doc.cadn.net.cn

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);

}
import org.springframework.data.neo4j.repository.Neo4jRepository
import java.util.Optional

interface CityRepository : Neo4jRepository<City?, Long?> {

	fun findOneByNameAndState(name: String?, state: String?): Optional<City?>?

}

spring-boot-starter-data-neo4j 起步依赖可启用仓库支持以及事务管理。 Spring Boot 同时支持经典式和响应式 Neo4j 仓库，分别使用 Neo4jTemplate 或 ReactiveNeo4jTemplate Bean。 当类路径中存在 Project Reactor 时，响应式风格也会自动配置。spring-doc.cadn.net.cn

通过扫描查找仓库（Repositories）和实体（Entities）。 默认情况下，会扫描自动配置包。 您可分别使用@EnableNeo4jRepositories和@EntityScan来自定义查找仓库和实体的位置。spring-doc.cadn.net.cn

在采用响应式风格的应用程序中，ReactiveTransactionManager 不会自动配置。 若要启用事务管理，必须在您的配置中定义以下 Bean：spring-doc.cadn.net.cn

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);
	}

}
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)
class MyNeo4jConfiguration {

	@Bean
	fun reactiveTransactionManager(driver: Driver,
			databaseNameProvider: ReactiveDatabaseSelectionProvider): ReactiveNeo4jTransactionManager {
		return ReactiveNeo4jTransactionManager(driver, databaseNameProvider)
	}
}

弹性搜索

Elasticsearch 是一个开源的、分布式的、符合 REST 风格的搜索与分析引擎。 Spring Boot 为 Elasticsearch 客户端提供了基础的自动配置支持。spring-doc.cadn.net.cn

Spring Boot 支持多种客户端：spring-doc.cadn.net.cn

Spring Boot 提供了一个专用的Starters：spring-boot-starter-data-elasticsearch。spring-doc.cadn.net.cn

使用 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。 您可以使用 spring.elasticsearch.* 属性进一步调整客户端的配置，如下例所示：spring-doc.cadn.net.cn

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

使用 RestClient 连接到 Elasticsearch

如果类路径中存在 elasticsearch-rest-client，Spring Boot 将自动配置并注册一个 RestClient Bean。 除了前述属性外，您还可以注册任意数量实现 RestClientBuilderCustomizer 接口的 Bean，以对 RestClient 进行更高级的自定义配置。 如需完全掌控客户端的配置，请定义一个 RestClientBuilder Bean。spring-doc.cadn.net.cn

此外，如果类路径中存在 elasticsearch-rest-client-sniffer，则会自动配置一个 Sniffer，以自动发现正在运行的 Elasticsearch 集群中的节点，并将这些节点设置到 RestClient Bean 上。 您还可以进一步调整 Sniffer 的配置方式，如下例所示：spring-doc.cadn.net.cn

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

使用ElasticsearchClient连接到Elasticsearch

如果类路径中存在 co.elastic.clients:elasticsearch-java，Spring Boot 将自动配置并注册一个 ElasticsearchClient Bean。spring-doc.cadn.net.cn

ElasticsearchClient 使用一种传输机制，该机制依赖于前述的 RestClient。 因此，前述描述的属性可用于配置 ElasticsearchClient。 此外，您还可以定义一个 RestClientOptions Bean，以进一步控制该传输机制的行为。spring-doc.cadn.net.cn

使用 ReactiveElasticsearchClient 连接到 Elasticsearch

Spring Data Elasticsearch 提供了 ReactiveElasticsearchClient，用于以响应式方式查询 Elasticsearch 实例。 如果类路径中包含 Spring Data Elasticsearch 和 Reactor，Spring Boot 将自动配置并注册一个 ReactiveElasticsearchClient。spring-doc.cadn.net.cn

ReactiveElasticsearchClient 使用一种传输机制，该机制依赖于前述的 RestClient。 因此，前述描述的属性可用于配置 ReactiveElasticsearchClient。 此外，您还可以定义一个 RestClientOptions Bean，以进一步控制该传输机制的行为。spring-doc.cadn.net.cn

使用 Spring Data 连接到 Elasticsearch

要连接到 Elasticsearch，必须定义一个 ElasticsearchClient Bean，该 Bean 可由 Spring Boot 自动配置，也可由应用程序手动提供（参见前面的章节）。 配置完成后，ElasticsearchTemplate 即可像其他任何 Spring Bean 一样被注入，如下例所示：spring-doc.cadn.net.cn

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);
	}

}
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate ) {

	// ...

	fun someMethod(id: String): Boolean {
		return template.exists(id, User::class.java)
	}

}

当存在 spring-data-elasticsearch 和 Reactor 时，Spring Boot 还可自动将 ReactiveElasticsearchClient 和 ReactiveElasticsearchTemplate 配置为 Bean。 它们是其他 REST 客户端的响应式等效实现。spring-doc.cadn.net.cn

Spring Data Elasticsearch 仓库

Spring Data 包含对 Elasticsearch 的仓库支持。 与前面讨论的 JPA 仓库一样，其基本原理是：查询会根据方法名称自动为您构建。spring-doc.cadn.net.cn

事实上，Spring Data JPA 和 Spring Data Elasticsearch 共享相同的通用基础设施。 您可以采用前面的 JPA 示例，并假设此处的 City 现在是一个 Elasticsearch @Document 类，而非 JPA @Entity 类，那么该示例将以相同的方式运行。spring-doc.cadn.net.cn

通过扫描查找仓库和文档。 默认情况下，将扫描自动配置包。 您可分别使用@EnableElasticsearchRepositories和@EntityScan来自定义查找仓库和文档的位置。spring-doc.cadn.net.cn

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

Spring Boot 支持经典型和响应式两种 Elasticsearch 仓库，分别使用 ElasticsearchTemplate 或 ReactiveElasticsearchTemplate Bean。 只要引入了所需的依赖，这些 Bean 很可能由 Spring Boot 自动配置。spring-doc.cadn.net.cn

如果您希望使用自定义模板来支持 Elasticsearch 仓库，可以添加您自己的 ElasticsearchTemplate 或 ElasticsearchOperations @Bean，只要其名称为 "elasticsearchTemplate" 即可。 对于 ReactiveElasticsearchTemplate 和 ReactiveElasticsearchOperations 同样适用，其 Bean 名称为 "reactiveElasticsearchTemplate"。spring-doc.cadn.net.cn

您可以使用以下属性来禁用仓库（Repository）支持：spring-doc.cadn.net.cn

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

Cassandra

Cassandra 是一个开源的分布式数据库管理系统，专为在大量商用服务器上处理海量数据而设计。 Spring Boot 提供了对 Cassandra 的自动配置，以及 Spring Data Cassandra 在其之上提供的抽象层。 有一个 spring-boot-starter-data-cassandra Starters，可方便地整合相关依赖。spring-doc.cadn.net.cn

连接到 Cassandra

您可以像注入其他任意 Spring Bean 一样，注入一个已自动配置的 CqlTemplate、CassandraTemplate 或 Cassandra CqlSession 实例。 可使用 spring.cassandra.* 属性来自定义连接。 通常，您还需提供 keyspace-name 和 contact-points 以及本地数据中心名称，如下例所示：spring-doc.cadn.net.cn

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

如果所有联系点的端口都相同，您可以使用快捷方式，仅指定主机名，如下例所示：spring-doc.cadn.net.cn

spring.cassandra.keyspace-name=mykeyspace
spring.cassandra.contact-points=cassandrahost1,cassandrahost2
spring.cassandra.local-datacenter=datacenter1
spring:
  cassandra:
    keyspace-name: "mykeyspace"
    contact-points: "cassandrahost1,cassandrahost2"
    local-datacenter: "datacenter1"
这两个示例完全相同，因为端口默认为 9042。 如果需要配置端口，请使用 spring.cassandra.port。

自动配置的 CqlSession 可通过设置如下示例所示的属性，配置为使用 SSL 与服务器进行通信：spring-doc.cadn.net.cn

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

自定义 SSL 信任材料可在 SSL 绑定包 中进行配置，并应用于 CqlSession，如下例所示：spring-doc.cadn.net.cn

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

Cassandra 驱动程序拥有自身的配置基础设施，该设施会在类路径根目录下加载一个 application.conf。spring-doc.cadn.net.cn

Spring Boot 默认不会查找此类文件，但可以使用 spring.cassandra.config 加载该文件。 如果某个属性同时存在于 spring.cassandra.* 和配置文件中，则 spring.cassandra.* 中的值具有更高优先级。spring-doc.cadn.net.cn

如需进行更高级的驱动程序自定义，您可以注册任意数量实现 DriverConfigLoaderBuilderCustomizer 接口的 Bean。 CqlSession 可通过类型为 CqlSessionBuilderCustomizer 的 Bean 进行自定义。spring-doc.cadn.net.cn
如果使用 CqlSessionBuilder 创建多个 CqlSession Bean，请注意构建器是可变的，因此请确保为每个会话注入一个全新的副本。

以下代码清单展示了如何注入一个 Cassandra Bean：spring-doc.cadn.net.cn

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);
	}

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

@Component
class MyBean(private val template: CassandraTemplate) {

	// ...

	fun someMethod(): Long {
		return template.count(User::class.java)
	}

}

如果您添加了自己类型的 @Bean（类型为 CassandraTemplate），它将替换默认实现。spring-doc.cadn.net.cn

Spring Data Cassandra 仓库

Spring Data 为 Cassandra 提供了基础的仓库（Repository）支持。 目前，该支持相比之前讨论的 JPA 仓库功能更为有限，且需要使用 @Query 个带注解的查询方法。spring-doc.cadn.net.cn

通过扫描查找仓库（Repositories）和实体（Entities）。 默认情况下，会扫描自动配置包。 您可分别使用@EnableCassandraRepositories和@EntityScan来自定义查找仓库和实体的位置。spring-doc.cadn.net.cn

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

Couchbase

Couchbase 是一个开源的、分布式的、多模型的 NoSQL 文档型数据库，专为交互式应用程序优化。 Spring Boot 提供了针对 Couchbase 的自动配置，以及由 Spring Data Couchbase 提供的高层抽象。 提供了 spring-boot-starter-data-couchbase 和 spring-boot-starter-data-couchbase-reactive 两种Starters，以便便捷地管理依赖项。spring-doc.cadn.net.cn

连接到 Couchbase

通过添加 Couchbase SDK 并进行一些配置，您可以获得一个 Cluster。 spring.couchbase.* 属性可用于自定义连接。 通常，您需要提供 连接字符串 以及用于身份验证的凭据。以下示例展示了如何配置基于用户名和密码的基本身份验证：spring-doc.cadn.net.cn

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

客户端证书可用于身份验证，以替代用户名和密码。 包含客户端证书的 Java 密钥库（KeyStore）的位置和密码可按以下示例进行配置：spring-doc.cadn.net.cn

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
spring:
  couchbase:
    connection-string: "couchbase://192.168.1.123"
    env:
      ssl:
        enabled: true
    authentication:
      jks:
        location: "classpath:client.p12"
        password: "secret"

PEM 编码的证书和私钥可以按以下示例进行配置：spring-doc.cadn.net.cn

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
spring:
  couchbase:
    connection-string: "couchbase://192.168.1.123"
    env:
      ssl:
        enabled: true
    authentication:
      pem:
        certificates: "classpath:client.crt"
        private-key: "classpath:client.key"

还可以自定义部分 ClusterEnvironment 设置。 例如，以下配置将打开新 Bucket 的超时时间更改为指定值，并通过引用已配置的 SSL 绑定包 启用 SSL 支持：spring-doc.cadn.net.cn

spring.couchbase.env.timeouts.connect=3s
spring.couchbase.env.ssl.bundle=example
spring:
  couchbase:
    env:
      timeouts:
        connect: "3s"
      ssl:
        bundle: "example"
请查看 spring.couchbase.env.* 属性以了解更多信息。 如需更多控制权，可使用一个或多个 ClusterEnvironmentBuilderCustomizer Bean。

Spring Data Couchbase 仓库

Spring Data 包含对 Couchbase 的仓库支持。spring-doc.cadn.net.cn

通过扫描查找仓库和文档。 默认情况下，将扫描自动配置包。 您可分别使用@EnableCouchbaseRepositories和@EntityScan来自定义查找仓库和文档的位置。spring-doc.cadn.net.cn

有关 Spring Data Couchbase 的完整详细信息，请参阅 参考文档。spring-doc.cadn.net.cn

只要存在一个 CouchbaseClientFactory Bean，您就可以像注入其他任意 Spring Bean 一样，注入一个已自动配置的 CouchbaseTemplate 实例。 当存在一个 Cluster（如上所述）且已指定存储桶名称时，便会触发此行为：spring-doc.cadn.net.cn

spring.data.couchbase.bucket-name=my-bucket
spring:
  data:
    couchbase:
      bucket-name: "my-bucket"

以下示例展示了如何注入一个 CouchbaseTemplate Bean：spring-doc.cadn.net.cn

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();
	}

}
import org.springframework.data.couchbase.core.CouchbaseTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: CouchbaseTemplate) {

	// ...

	fun someMethod(): String {
		return template.bucketName
	}

}

您可以自行在配置中定义若干 Bean，以覆盖自动配置所提供的 Bean：spring-doc.cadn.net.cn

为避免在您自己的配置中硬编码这些名称，您可以复用 Spring Data Couchbase 提供的 BeanNames。 例如，您可以按如下方式自定义要使用的转换器：spring-doc.cadn.net.cn

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()));
	}

}
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)
class MyCouchbaseConfiguration {

	@Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
	fun myCustomConversions(): CouchbaseCustomConversions {
		return CouchbaseCustomConversions(Arrays.asList(MyConverter()))
	}

}

LDAP

LDAP（轻量级目录访问协议）是一种开放、与提供商无关、业界标准的应用层协议，用于通过 IP 网络访问和维护分布式目录信息服务。 Spring Boot 提供了对任意兼容 LDAP 服务器的自动配置支持，同时也支持来自 UnboundID 的嵌入式内存 LDAP 服务器。spring-doc.cadn.net.cn

LDAP 抽象由 Spring Data LDAP 提供。 有一个 spring-boot-starter-data-ldap Starters，可方便地收集相关依赖项。spring-doc.cadn.net.cn

连接到LDAP服务器

要连接到 LDAP 服务器，请确保在项目中声明对 spring-boot-starter-data-ldap Starters或 spring-ldap-core 的依赖，然后在 application.properties 文件中声明服务器的 URL，如下例所示：spring-doc.cadn.net.cn

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

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

将根据这些设置自动配置一个 LdapContextSource。 如果存在一个 DirContextAuthenticationStrategy Bean，则会将其关联到自动配置的 LdapContextSource。 如果您需要对其进行自定义（例如，使用一个 PooledContextSource），仍可注入该自动配置的 LdapContextSource。 请确保将您自定义的 ContextSource 标记为 @Primary，以便自动配置的 LdapTemplate 能够使用它。spring-doc.cadn.net.cn

Spring Data LDAP 仓库

Spring Data 包含对 LDAP 的仓库支持。spring-doc.cadn.net.cn

通过扫描查找仓库和文档。 默认情况下，将扫描自动配置包。 您可分别使用@EnableLdapRepositories和@EntityScan来自定义查找仓库和文档的位置。spring-doc.cadn.net.cn

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

您还可以像注入其他任何 Spring Bean 一样，注入一个自动配置的 LdapTemplate 实例，如下例所示：spring-doc.cadn.net.cn

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);
	}

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

@Component
class MyBean(private val template: LdapTemplate) {

	// ...

	fun someMethod(): List<User> {
		return template.findAll(User::class.java)
	}

}

嵌入式内存LDAP服务器

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

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

可以定义多个 base-dn 值，但由于专有名称（distinguished names）通常包含逗号，因此必须使用正确的符号表示法来定义它们。spring-doc.cadn.net.cn

在 YAML 文件中，可以使用 YAML 列表表示法。在 properties 文件中，必须将索引作为属性名称的一部分包含在内：spring-doc.cadn.net.cn

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

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

如果类路径下存在 schema.ldif 文件，则使用该文件来初始化服务器。 如果您希望从其他资源加载初始化脚本，也可以使用 spring.ldap.embedded.ldif 属性。spring-doc.cadn.net.cn

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