使用 NoSQL 技术

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

在这些技术中，Spring Boot 为 Cassandra、Couchbase、Elasticsearch、LDAP、MongoDB、Neo4J 和 Redis 提供了自动配置。此外，适用于 Apache Geode 的 Spring Boot 提供了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 启动器，可以方便地收集依赖项。默认情况下，它使用 Lettuce。该启动器同时处理传统和反应式应用程序。

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

连接到 Redis

您可以像注入其他 Spring Bean 一样注入自动配置的 RedisConnectionFactory、StringRedisTemplate 或普通的 RedisTemplate 实例。以下清单显示了一个这样的 Bean 示例

Java
Kotlin

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.* 属性指定自定义连接详细信息，如下例所示

属性
YAML

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 时，主机、端口、用户名和密码属性将被忽略。以下示例显示了这一点

属性
YAML

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 而不是其类型）。

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

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

属性
YAML

spring.data.redis.ssl.enabled=true

spring:
  data:
    redis:
      ssl:
        enabled: true

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

属性
YAML

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 启动器。

连接到 MongoDB 数据库

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

Java
Kotlin

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。

自动配置的 MongoClient 是使用 MongoClientSettings Bean 创建的。如果您已定义了自己的 MongoClientSettings，它将原样使用，并且 spring.data.mongodb 属性将被忽略。否则，将自动配置 MongoClientSettings，并将 spring.data.mongodb 属性应用于它。在这两种情况下，您都可以声明一个或多个 MongoClientSettingsBuilderCustomizer Bean 来微调 MongoClientSettings 配置。每个 Bean 将按照顺序调用，并使用用于构建 MongoClientSettings 的 MongoClientSettings.Builder。

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

属性
YAML

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 中声明以下设置

属性
YAML

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 与服务器通信

属性
YAML

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，如下例所示

属性
YAML

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。您可以从前面显示的示例中删除此行。

您还可以使用 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 以注入模板，如下所示

Java
Kotlin

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 Data MongoDB 存储库

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

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

Java
Kotlin

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 Data MongoDB 的完整详细信息（包括其丰富的对象映射技术），请参阅其参考文档。

Neo4j

Neo4j 是一种开源的 NoSQL 图数据库，它使用节点通过一流关系连接的丰富数据模型，这比传统的 RDBMS 方法更适合于连接的大数据。Spring Boot 提供了几种用于处理 Neo4j 的便利功能，包括 spring-boot-starter-data-neo4j 启动器。

连接到 Neo4j 数据库

要访问 Neo4j 服务器，您可以注入自动配置的 org.neo4j.driver.Driver。默认情况下，该实例尝试使用 Bolt 协议连接到 localhost:7687 上的 Neo4j 服务器。以下示例显示了如何注入 Neo4j Driver，它使您可以访问（除其他事项外）Session

Java
Kotlin

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.*
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 和凭据

属性
YAML

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 是使用 ConfigBuilder 创建的。要微调其配置，请声明一个或多个 ConfigBuilderCustomizer Bean。每个 Bean 将按照顺序调用，并使用用于构建 Driver 的 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，并且存储库抽象以相同的方式工作，如下例所示

Java
Kotlin

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 时，响应式样式也会自动配置。

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

在使用响应式样式的应用程序中，不会自动配置 ReactiveTransactionManager。要启用事务管理，必须在您的配置中定义以下 Bean

Java
Kotlin

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

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

Spring Boot 支持多个客户端

官方的低级 REST 客户端
官方的 Java API 客户端
Spring Data Elasticsearch 提供的 ReactiveElasticsearchClient

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 为目标。您可以使用 spring.elasticsearch.* 属性进一步调整客户端的配置方式，如下例所示

属性
YAML

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。除了前面描述的属性之外，要微调 RestClient，您可以注册任意数量的实现 RestClientBuilderCustomizer 接口的 Bean 以进行更高级的自定义。要完全控制客户端的配置，请定义一个 RestClientBuilder Bean。

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

属性
YAML

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。

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，如下例所示

Java
Kotlin

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 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 存储库，使用 ElasticsearchRestTemplate 或 ReactiveElasticsearchTemplate bean。如果存在所需的依赖项，Spring Boot 很可能自动配置这些 bean。

如果您希望使用自己的模板来支持 Elasticsearch 存储库，您可以添加自己的 ElasticsearchRestTemplate 或 ElasticsearchOperations @Bean，只要它命名为 "elasticsearchTemplate"。ReactiveElasticsearchTemplate 和 ReactiveElasticsearchOperations 也是如此，bean 名称为 "reactiveElasticsearchTemplate"。

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

属性
YAML

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 启动器可以方便地收集依赖项。

连接到 Cassandra

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

属性
YAML

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"

如果所有联系点的端口都相同，您可以使用快捷方式，只指定主机名，如下例所示

属性
YAML

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 与服务器通信

属性
YAML

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，如下例所示

属性
YAML

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 Boot 默认情况下不会查找此类文件，但可以使用 spring.cassandra.config 加载一个。如果 spring.cassandra.* 和配置文件中都存在某个属性，则 spring.cassandra.* 中的值优先。

对于更高级的驱动程序自定义，您可以注册任意数量的实现 DriverConfigLoaderBuilderCustomizer 的 bean。可以使用类型为 CqlSessionBuilderCustomizer 的 bean 自定义 CqlSession。

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

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

Java
Kotlin

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

}

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

Spring Data Cassandra 存储库

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

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

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

Couchbase

Couchbase 是一种开源的分布式多模型 NoSQL 文档型数据库，针对交互式应用程序进行了优化。Spring Boot 为 Couchbase 提供自动配置，以及 Spring Data Couchbase 提供的抽象。有 spring-boot-starter-data-couchbase 和 spring-boot-starter-data-couchbase-reactive 启动器可以方便地收集依赖项。

连接到 Couchbase

您可以通过添加 Couchbase SDK 和一些配置来获取 Cluster。spring.couchbase.* 属性可用于自定义连接。通常，您需要提供连接字符串、用户名和密码，如下例所示

属性
YAML

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"

还可以自定义一些 ClusterEnvironment 设置。例如，以下配置将打开新 Bucket 的超时时间更改为，并启用 SSL 支持，并引用已配置的 SSL 捆绑包

属性
YAML

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 的存储库支持。

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

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

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

属性
YAML

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

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

以下示例显示了如何注入 CouchbaseTemplate bean

Java
Kotlin

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

一个名为 couchbaseMappingContext 的 CouchbaseMappingContext @Bean。
一个名为 couchbaseCustomConversions 的 CustomConversions @Bean。
一个名为 couchbaseTemplate 的 CouchbaseTemplate @Bean。

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

Java
Kotlin

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 服务器的支持。

LDAP 抽象由 Spring Data LDAP 提供。有一个 spring-boot-starter-data-ldap 启动器可以方便地收集依赖项。

连接到 LDAP 服务器

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

属性
YAML

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 属性。

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

Spring Data LDAP 存储库

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

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

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

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

Java
Kotlin

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 属性，如下所示

属性
YAML

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

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

可以定义多个 base-dn 值，但是由于区分名称通常包含逗号，因此必须使用正确的表示法来定义它们。

在 yaml 文件中，可以使用 yaml 列表表示法。在属性文件中，必须将索引包含在属性名称中

属性
YAML

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 属性。

如果您的类路径上存在 schema.ldif 文件，则将其用于初始化服务器。如果要从不同的资源加载初始化脚本，还可以使用 spring.ldap.embedded.ldif 属性。

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

InfluxDB

InfluxDB 的自动配置已弃用，并计划在 Spring Boot 3.4 中删除，以支持新的 InfluxDB Java 客户端，该客户端提供自己的 Spring Boot 集成。

InfluxDB 是一个开源时间序列数据库，针对快速、高可用性存储和检索时间序列数据进行了优化，这些数据应用于操作监控、应用程序指标、物联网传感器数据和实时分析等领域。

连接到 InfluxDB

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

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

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

如果您需要更多地控制配置，请考虑注册一个 InfluxDbCustomizer bean。