使用 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 为 Lettuce 和 Jedis 客户端库以及 Spring Data Redis 在其上提供的抽象提供了基本自动配置。
提供了一个 spring-boot-starter-data-redis
starter,用于方便地收集依赖。默认情况下,它使用 Lettuce。该 starter 支持传统应用和响应式应用。
我们还提供了一个 spring-boot-starter-data-redis-reactive starter,以便与其他支持响应式的存储保持一致。 |
连接到 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.*
属性指定自定义连接详情,如下例所示
-
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 也可用。另外,您可以注册一个 RedisStandaloneConfiguration 、RedisSentinelConfiguration 或 RedisClusterConfiguration 类型的 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-mongodb
和 spring-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 都将按顺序调用用于构建 MongoClientSettings
的 MongoClientSettings.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,可以注入 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
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 都将按顺序调用用于构建 Driver
的 org.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 使用 Neo4jTemplate
或 ReactiveNeo4jTemplate
bean 支持经典和响应式 Neo4j 仓库。当 classpath 中存在 Project Reactor 时,也会自动配置响应式风格。
通过扫描查找仓库和实体。默认情况下,会自动扫描自动配置包。您可以使用 @EnableNeo4jRepositories
和 @EntityScan
分别自定义查找仓库和实体的位置。
在使用响应式风格的应用中,
|
Elasticsearch
Elasticsearch 是一个开源、分布式、RESTful 的搜索和分析引擎。Spring Boot 为 Elasticsearch 客户端提供了基本自动配置。
Spring Boot 支持多种客户端
-
官方的低级 REST 客户端
-
官方的 Java API 客户端
-
Spring Data Elasticsearch 提供的
ReactiveElasticsearchClient
Spring Boot 提供了一个专用的 starter,即 spring-boot-starter-data-elasticsearch
。
使用 REST 客户端连接到 Elasticsearch
Elasticsearch 提供了两种不同的 REST 客户端,可用于查询集群:来自 org.elasticsearch.client:elasticsearch-rest-client
模块的低级客户端,以及来自 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 还可以自动配置 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"
。
你可以使用以下属性禁用仓库支持:
-
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-name
和 contact-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 的根目录加载一个 Spring Boot 默认不查找此类文件,但可以使用 对于更高级的驱动程序自定义,可以注册任意数量的实现 |
如果使用 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-couchbase
和 spring-boot-starter-data-couchbase-reactive
启动器,用于方便地收集依赖项。
连接到 Couchbase
通过添加 Couchbase SDK 和一些配置,你可以获得一个 Cluster
。spring.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:
-
一个名称为
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,如下例所示:
-
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.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
属性,如下所示:
-
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 文件中,必须将索引包含在属性名称中:
|
默认情况下,服务器在随机端口上启动,并触发常规的 LDAP 支持。无需指定 spring.ldap.urls
属性。
如果 classpath 中存在 schema.ldif
文件,它将用于初始化服务器。如果想从不同的资源加载初始化脚本,也可以使用 spring.ldap.embedded.ldif
属性。
默认情况下,使用标准模式验证 LDIF
文件。可以通过设置 spring.ldap.embedded.validation.enabled
属性来完全关闭验证。如果具有自定义属性,可以使用 spring.ldap.embedded.validation.schema
定义自定义属性类型或对象类。