使用 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 客户端提供了自动配置,但该客户端已弃用,推荐使用提供自身 Spring Boot 集成的新版 InfluxDB Java 客户端

Redis

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

提供了一个 spring-boot-starter-data-redis starter,用于方便地收集依赖。默认情况下,它使用 Lettuce。该 starter 支持传统应用和响应式应用。

我们还提供了一个 spring-boot-starter-data-redis-reactive starter,以便与其他支持响应式的存储保持一致。

连接到 Redis

您可以像注入其他 Spring Bean 一样,注入自动配置的 RedisConnectionFactoryStringRedisTemplate 或原生的 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.* 属性指定自定义连接详情,如下例所示

  • Properties

  • 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 时,将忽略 host、port、username 和 password 属性。如下例所示

  • Properties

  • 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 也可用。另外,您可以注册一个 RedisStandaloneConfigurationRedisSentinelConfigurationRedisClusterConfiguration 类型的 bean,以便完全控制配置。

如果您添加了自己的任意自动配置类型的 @Bean,它将替换默认配置(RedisTemplate 除外,在这种情况下,排除是基于 bean 名称 redisTemplate,而不是其类型)。

默认情况下,如果 commons-pool2 在 classpath 中,将自动配置一个连接池工厂。

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

  • Properties

  • YAML

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

可以在 SSL bundle 中配置自定义 SSL 信任材料,并将其应用于 RedisConnectionFactory,如下例所示

  • Properties

  • YAML

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

MongoDB

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

连接到 MongoDB 数据库

要访问 MongoDB 数据库,您可以注入一个自动配置的 MongoDatabaseFactory。默认情况下,实例会尝试连接到 mongodb://localhost/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 都将按顺序调用用于构建 MongoClientSettingsMongoClientSettings.Builder

您可以设置 spring.data.mongodb.uri 属性来更改 URL 并配置附加设置,例如 *副本集 (replica set)*,如下例所示

  • Properties

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

  • 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 与服务器通信,通过设置属性即可,如下例所示

  • Properties

  • 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 bundle 中配置自定义 SSL 信任材料,并将其应用于 MongoClient,如下例所示

  • Properties

  • 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 连接的建立,也可以声明自己的 MongoDatabaseFactoryMongoClient 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 starter。

连接到 Neo4j 数据库

要访问 Neo4j 服务器,您可以注入一个自动配置的 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.* 属性配置 driver 的各个方面。以下示例展示了如何配置要使用的 uri 和凭据

  • Properties

  • 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 是使用 org.neo4j.driver.Config$ConfigBuilder 创建的。为了微调其配置,请声明一个或多个 ConfigBuilderCustomizer bean。每个 bean 都将按顺序调用用于构建 Driverorg.neo4j.driver.Config$ConfigBuilder

Spring Data Neo4j 仓库

Spring Data 包含对 Neo4j 的仓库支持。有关 Spring Data Neo4j 的完整详情,请参阅参考文档

Spring Data Neo4j 与许多其他 Spring Data 模块一样,共享 Spring Data JPA 的通用基础设施。您可以采用之前的 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 starter 启用了仓库支持以及事务管理。Spring Boot 使用 Neo4jTemplateReactiveNeo4jTemplate bean 支持经典和响应式 Neo4j 仓库。当 classpath 中存在 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 支持多种客户端

Spring Boot 提供了一个专用的 starter,即 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.* 属性进一步调整客户端的配置方式,如下例所示

  • Properties

  • 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 在 classpath 中,Spring Boot 将自动配置并注册一个 RestClient bean。除了前面描述的属性外,要微调 RestClient,您可以注册任意数量实现 RestClientBuilderCustomizer 的 bean,用于更高级的自定义。要完全控制客户端的配置,请定义一个 RestClientBuilder bean。

此外,如果 elasticsearch-rest-client-sniffer 在 classpath 中,将自动配置一个 Sniffer,用于自动发现正在运行的 Elasticsearch 集群中的节点,并将其设置到 RestClient bean 上。您可以进一步调整 Sniffer 的配置方式,如下例所示

  • Properties

  • 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 在 classpath 中,Spring Boot 将自动配置并注册一个 ElasticsearchClient bean。

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

使用 ReactiveElasticsearchClient 连接到 Elasticsearch

Spring Data Elasticsearch 提供了 ReactiveElasticsearchClient,用于以响应式方式查询 Elasticsearch 实例。如果你的 classpath 中有 Spring Data Elasticsearch 和 Reactor,Spring Boot 将自动配置并注册一个 ReactiveElasticsearchClient

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

使用 Spring Data 连接到 Elasticsearch

要连接到 Elasticsearch,必须定义一个 ElasticsearchClient 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 还可以自动配置 ReactiveElasticsearchClientReactiveElasticsearchTemplate 作为 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 仓库,使用 ElasticsearchTemplateReactiveElasticsearchTemplate bean。如果存在所需的依赖项,这些 bean 很可能由 Spring Boot 自动配置。

如果你希望使用自己的模板来支持 Elasticsearch 仓库,可以添加自己的 ElasticsearchTemplateElasticsearchOperations @Bean,只要其名称为 "elasticsearchTemplate"。同样适用于 ReactiveElasticsearchTemplateReactiveElasticsearchOperations,其 bean 名称为 "reactiveElasticsearchTemplate"

你可以使用以下属性禁用仓库支持:

  • Properties

  • 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-namecontact-points 以及本地数据中心名称,如下例所示:

  • Properties

  • 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"

如果所有 contact points 的端口相同,可以使用快捷方式,只指定主机名,如下例所示:

  • Properties

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

  • Properties

  • 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,如下例所示:

  • Properties

  • 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 驱动程序有自己的配置基础设施,它会在 classpath 的根目录加载一个 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,它将替换默认的 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-couchbasespring-boot-starter-data-couchbase-reactive 启动器,用于方便地收集依赖项。

连接到 Couchbase

通过添加 Couchbase SDK 和一些配置,你可以获得一个 Clusterspring.couchbase.* 属性可以用来定制连接。通常,你需要提供连接字符串和用于身份验证的凭证。可以使用用户名和密码进行基本身份验证,如下例所示:

  • Properties

  • 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"

可以使用客户端证书进行身份验证,而不是使用用户名和密码。包含客户端证书的 Java KeyStore 的位置和密码可以配置,如下例所示:

  • Properties

  • YAML

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 编码的证书和私钥可以配置,如下例所示:

  • Properties

  • YAML

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 支持:

  • Properties

  • 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 的完整详情,请参阅其参考文档

如果 CouchbaseClientFactory bean 可用,你可以像注入任何其他 Spring Bean 一样注入自动配置的 CouchbaseTemplate 实例。当 Cluster 可用(如上所述)且已指定 bucket 名称时,就会发生这种情况:

  • Properties

  • 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:

为了避免在自己的配置中硬编码这些名称,可以重用 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,如下例所示:

  • Properties

  • 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.basespring.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 属性,如下所示:

  • Properties

  • YAML

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

可以定义多个 base-dn 值,但是,由于专有名称通常包含逗号,必须使用正确的符号进行定义。

在 yaml 文件中,可以使用 yaml 列表符号。在 properties 文件中,必须将索引包含在属性名称中:

  • Properties

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

如果 classpath 中存在 schema.ldif 文件,它将用于初始化服务器。如果想从不同的资源加载初始化脚本,也可以使用 spring.ldap.embedded.ldif 属性。

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