575 lines
27 KiB
Plaintext
575 lines
27 KiB
Plaintext
[[data.nosql]]
|
|
== Working with NoSQL Technologies
|
|
Spring Data provides additional projects that help you access a variety of NoSQL technologies, including:
|
|
|
|
* {spring-data-mongodb}[MongoDB]
|
|
* {spring-data-neo4j}[Neo4J]
|
|
* {spring-data-elasticsearch}[Elasticsearch]
|
|
* {spring-data-redis}[Redis]
|
|
* {spring-data-gemfire}[GemFire] or {spring-data-geode}[Geode]
|
|
* {spring-data-cassandra}[Cassandra]
|
|
* {spring-data-couchbase}[Couchbase]
|
|
* {spring-data-ldap}[LDAP]
|
|
|
|
Spring Boot provides auto-configuration for Redis, MongoDB, Neo4j, Elasticsearch, Cassandra, Couchbase, LDAP and InfluxDB.
|
|
Additionally, {spring-boot-for-apache-geode}[Spring Boot for Apache Geode] provides {spring-boot-for-apache-geode-docs}#geode-repositories[auto-configuration for Apache Geode].
|
|
You can make use of the other projects, but you must configure them yourself.
|
|
See the appropriate reference documentation at {spring-data}.
|
|
|
|
|
|
|
|
[[data.nosql.redis]]
|
|
=== Redis
|
|
https://redis.io/[Redis] is a cache, message broker, and richly-featured key-value store.
|
|
Spring Boot offers basic auto-configuration for the https://github.com/lettuce-io/lettuce-core/[Lettuce] and https://github.com/xetorthio/jedis/[Jedis] client libraries and the abstractions on top of them provided by https://github.com/spring-projects/spring-data-redis[Spring Data Redis].
|
|
|
|
There is a `spring-boot-starter-data-redis` "`Starter`" for collecting the dependencies in a convenient way.
|
|
By default, it uses https://github.com/lettuce-io/lettuce-core/[Lettuce].
|
|
That starter handles both traditional and reactive applications.
|
|
|
|
TIP: We also provide a `spring-boot-starter-data-redis-reactive` "`Starter`" for consistency with the other stores with reactive support.
|
|
|
|
|
|
|
|
[[data.nosql.redis.connecting]]
|
|
==== Connecting to Redis
|
|
You can inject an auto-configured `RedisConnectionFactory`, `StringRedisTemplate`, or vanilla `RedisTemplate` instance as you would any other Spring Bean.
|
|
By default, the instance tries to connect to a Redis server at `localhost:6379`.
|
|
The following listing shows an example of such a bean:
|
|
|
|
include::code:MyBean[]
|
|
|
|
TIP: You can also register an arbitrary number of beans that implement `LettuceClientConfigurationBuilderCustomizer` for more advanced customizations.
|
|
`ClientResources` can also be customized using `ClientResourcesBuilderCustomizer`.
|
|
If you use Jedis, `JedisClientConfigurationBuilderCustomizer` is also available.
|
|
Alternatively, you can register a bean of type `RedisStandaloneConfiguration`, `RedisSentinelConfiguration`, or `RedisClusterConfiguration` to take full control over the configuration.
|
|
|
|
If you add your own `@Bean` of any of the auto-configured types, it replaces the default (except in the case of `RedisTemplate`, when the exclusion is based on the bean name, `redisTemplate`, not its type).
|
|
|
|
By default, a pooled connection factory is auto-configured if `commons-pool2` is on the classpath.
|
|
|
|
|
|
|
|
[[data.nosql.mongodb]]
|
|
=== MongoDB
|
|
https://www.mongodb.com/[MongoDB] is an open-source NoSQL document database that uses a JSON-like schema instead of traditional table-based relational data.
|
|
Spring Boot offers several conveniences for working with MongoDB, including the `spring-boot-starter-data-mongodb` and `spring-boot-starter-data-mongodb-reactive` "`Starters`".
|
|
|
|
|
|
|
|
[[data.nosql.mongodb.connecting]]
|
|
==== Connecting to a MongoDB Database
|
|
To access MongoDB databases, you can inject an auto-configured `org.springframework.data.mongodb.MongoDatabaseFactory`.
|
|
By default, the instance tries to connect to a MongoDB server at `mongodb://localhost/test`.
|
|
The following example shows how to connect to a MongoDB database:
|
|
|
|
include::code:MyBean[]
|
|
|
|
If you have defined your own `MongoClient`, it will be used to auto-configure a suitable `MongoDatabaseFactory`.
|
|
|
|
The auto-configured `MongoClient` is created using a `MongoClientSettings` bean.
|
|
If you have defined your own `MongoClientSettings`, it will be used without modification and the `spring.data.mongodb` properties will be ignored.
|
|
Otherwise a `MongoClientSettings` will be auto-configured and will have the `spring.data.mongodb` properties applied to it.
|
|
In either case, you can declare one or more `MongoClientSettingsBuilderCustomizer` beans to fine-tune the `MongoClientSettings` configuration.
|
|
Each will be called in order with the `MongoClientSettings.Builder` that is used to build the `MongoClientSettings`.
|
|
|
|
You can set the configprop:spring.data.mongodb.uri[] property to change the URL and configure additional settings such as the _replica set_, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
data:
|
|
mongodb:
|
|
uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"
|
|
----
|
|
|
|
Alternatively, you can specify connection details using discrete properties.
|
|
For example, you might declare the following settings in your `application.properties`:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
data:
|
|
mongodb:
|
|
host: "mongoserver1.example.com"
|
|
port: 27017
|
|
additional-hosts:
|
|
- "mongoserver2.example.com:23456"
|
|
database: "test"
|
|
username: "user"
|
|
password: "secret"
|
|
----
|
|
|
|
[TIP]
|
|
====
|
|
If `spring.data.mongodb.port` is not specified, the default of `27017` is used.
|
|
You could delete this line from the example shown earlier.
|
|
|
|
You can also specify the port as part of the host address by using the `host:port` syntax.
|
|
This format should be used if you need to change the port of an `additional-hosts` entry.
|
|
====
|
|
|
|
TIP: If you do not use Spring Data MongoDB, you can inject a `MongoClient` bean instead of using `MongoDatabaseFactory`.
|
|
If you want to take complete control of establishing the MongoDB connection, you can also declare your own `MongoDatabaseFactory` or `MongoClient` bean.
|
|
|
|
NOTE: If you are using the reactive driver, Netty is required for SSL.
|
|
The auto-configuration configures this factory automatically if Netty is available and the factory to use has not been customized already.
|
|
|
|
|
|
|
|
[[data.nosql.mongodb.template]]
|
|
==== MongoTemplate
|
|
{spring-data-mongodb}[Spring Data MongoDB] provides a {spring-data-mongodb-api}/core/MongoTemplate.html[`MongoTemplate`] class that is very similar in its design to Spring's `JdbcTemplate`.
|
|
As with `JdbcTemplate`, Spring Boot auto-configures a bean for you to inject the template, as follows:
|
|
|
|
include::code:MyBean[]
|
|
|
|
See the {spring-data-mongodb-api}/core/MongoOperations.html[`MongoOperations` Javadoc] for complete details.
|
|
|
|
|
|
|
|
[[data.nosql.mongodb.repositories]]
|
|
==== Spring Data MongoDB Repositories
|
|
Spring Data includes repository support for MongoDB.
|
|
As with the JPA repositories discussed earlier, the basic principle is that queries are constructed automatically, based on method names.
|
|
|
|
In fact, both Spring Data JPA and Spring Data MongoDB share the same common infrastructure.
|
|
You could take the JPA example from earlier and, assuming that `City` is now a MongoDB data class rather than a JPA `@Entity`, it works in the same way, as shown in the following example:
|
|
|
|
include::code:CityRepository[]
|
|
|
|
TIP: You can customize document scanning locations by using the `@EntityScan` annotation.
|
|
|
|
TIP: For complete details of Spring Data MongoDB, including its rich object mapping technologies, see its {spring-data-mongodb}[reference documentation].
|
|
|
|
|
|
|
|
[[data.nosql.neo4j]]
|
|
=== Neo4j
|
|
https://neo4j.com/[Neo4j] is an open-source NoSQL graph database that uses a rich data model of nodes connected by first class relationships, which is better suited for connected big data than traditional RDBMS approaches.
|
|
Spring Boot offers several conveniences for working with Neo4j, including the `spring-boot-starter-data-neo4j` "`Starter`".
|
|
|
|
|
|
|
|
[[data.nosql.neo4j.connecting]]
|
|
==== Connecting to a Neo4j Database
|
|
To access a Neo4j server, you can inject an auto-configured `org.neo4j.driver.Driver`.
|
|
By default, the instance tries to connect to a Neo4j server at `localhost:7687` using the Bolt protocol.
|
|
The following example shows how to inject a Neo4j `Driver` that gives you access, amongst other things, to a `Session`:
|
|
|
|
include::code:MyBean[]
|
|
|
|
You can configure various aspects of the driver using `spring.neo4j.*` properties.
|
|
The following example shows how to configure the uri and credentials to use:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
neo4j:
|
|
uri: "bolt://my-server:7687"
|
|
authentication:
|
|
username: "neo4j"
|
|
password: "secret"
|
|
----
|
|
|
|
The auto-configured `Driver` is created using `ConfigBuilder`.
|
|
To fine-tune its configuration, declare one or more `ConfigBuilderCustomizer` beans.
|
|
Each will be called in order with the `ConfigBuilder` that is used to build the `Driver`.
|
|
|
|
|
|
|
|
[[data.nosql.neo4j.repositories]]
|
|
==== Spring Data Neo4j Repositories
|
|
Spring Data includes repository support for Neo4j.
|
|
For complete details of Spring Data Neo4j, see the {spring-data-neo4j-docs}[reference documentation].
|
|
|
|
Spring Data Neo4j shares the common infrastructure with Spring Data JPA as many other Spring Data modules do.
|
|
You could take the JPA example from earlier and define `City` as Spring Data Neo4j `@Node` rather than JPA `@Entity` and the repository abstraction works in the same way, as shown in the following example:
|
|
|
|
include::code:CityRepository[]
|
|
|
|
The `spring-boot-starter-data-neo4j` "`Starter`" enables the repository support as well as transaction management.
|
|
Spring Boot supports both classic and reactive Neo4j repositories, using the `Neo4jTemplate` or `ReactiveNeo4jTemplate` beans.
|
|
When Project Reactor is available on the classpath, the reactive style is also auto-configured.
|
|
|
|
You can customize the locations to look for repositories and entities by using `@EnableNeo4jRepositories` and `@EntityScan` respectively on a `@Configuration`-bean.
|
|
|
|
[NOTE]
|
|
====
|
|
In an application using the reactive style, a `ReactiveTransactionManager` is not auto-configured.
|
|
To enable transaction management, the following bean must be defined in your configuration:
|
|
|
|
include::code:MyNeo4jConfiguration[]
|
|
====
|
|
|
|
|
|
|
|
[[data.nosql.elasticsearch]]
|
|
=== Elasticsearch
|
|
https://www.elastic.co/products/elasticsearch[Elasticsearch] is an open source, distributed, RESTful search and analytics engine.
|
|
Spring Boot offers basic auto-configuration for Elasticsearch clients.
|
|
|
|
Spring Boot supports several clients:
|
|
|
|
* The official low-level REST client
|
|
* The official Java API client
|
|
* The `ReactiveElasticsearchClient` provided by Spring Data Elasticsearch
|
|
|
|
Spring Boot provides a dedicated "`Starter`", `spring-boot-starter-data-elasticsearch`.
|
|
|
|
|
|
|
|
[[data.nosql.elasticsearch.connecting-using-rest]]
|
|
==== Connecting to Elasticsearch using REST clients
|
|
Elasticsearch ships two different REST clients] that you can use to query a cluster: the https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/java-rest-low.html[low-level client] from the `org.elasticsearch.client:elasticsearch-rest-client` module and the https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/index.html[Java API client] from the `co.elastic.clients:elasticsearch-java` module.
|
|
Additionally, Spring Boot provides support for a reactive client from the `org.springframework.data:spring-data-elasticsearch` module.
|
|
By default, the clients will target `http://localhost:9200`.
|
|
You can use `spring.elasticsearch.*` properties to further tune how the clients are configured, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
elasticsearch:
|
|
uris: "https://search.example.com:9200"
|
|
socket-timeout: "10s"
|
|
username: "user"
|
|
password: "secret"
|
|
----
|
|
|
|
[[data.nosql.elasticsearch.connecting-using-rest.restclient]]
|
|
===== Connecting to Elasticsearch using RestClient
|
|
If you have `elasticsearch-rest-client` on the classpath, Spring Boot will auto-configure and register a `RestClient` bean.
|
|
In addition to the properties described previously, to fine-tune the `RestClient` you can register an arbitrary number of beans that implement `RestClientBuilderCustomizer` for more advanced customizations.
|
|
To take full control over the clients' configuration, define a `RestClientBuilder` bean.
|
|
|
|
|
|
|
|
Additionally, if `elasticsearch-rest-client-sniffer` is on the classpath, a `Sniffer` is auto-configured to automatically discover nodes from a running Elasticsearch cluster and set them on the `RestClient` bean.
|
|
You can further tune how `Sniffer` is configured, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
elasticsearch:
|
|
restclient:
|
|
sniffer:
|
|
interval: "10m"
|
|
delay-after-failure: "30s"
|
|
----
|
|
|
|
|
|
[[data.nosql.elasticsearch.connecting-using-rest.javaapiclient]]
|
|
===== Connecting to Elasticsearch using ElasticsearchClient
|
|
If you have `co.elastic.clients:elasticsearch-java` on the classpath, Spring Boot will auto-configure and register an `ElasticsearchClient` bean.
|
|
|
|
The `ElasticsearchClient` uses a transport that depends upon the previously described `RestClient`.
|
|
Therefore, the properties described previously can be used to configure the `ElasticsearchClient`.
|
|
Furthermore, you can define a `TransportOptions` bean to take further control of the behavior of the transport.
|
|
|
|
|
|
|
|
[[data.nosql.elasticsearch.connecting-using-rest.reactiveclient]]
|
|
===== Connecting to Elasticsearch using ReactiveElasticsearchClient
|
|
{spring-data-elasticsearch}[Spring Data Elasticsearch] ships `ReactiveElasticsearchClient` for querying Elasticsearch instances in a reactive fashion.
|
|
If you have Spring Data Elasticsearch and Reactor on the classpath, Spring Boot will auto-configure and register a `ReactiveElasticsearchClient`.
|
|
|
|
The `ReactiveElasticsearchclient` uses a transport that depends upon the previously described `RestClient`.
|
|
Therefore, the properties described previously can be used to configure the `ReactiveElasticsearchClient`.
|
|
Furthermore, you can define a `TransportOptions` bean to take further control of the behavior of the transport.
|
|
|
|
|
|
|
|
[[data.nosql.elasticsearch.connecting-using-spring-data]]
|
|
==== Connecting to Elasticsearch by Using Spring Data
|
|
To connect to Elasticsearch, an `ElasticsearchClient` bean must be defined,
|
|
auto-configured by Spring Boot or manually provided by the application (see previous sections).
|
|
With this configuration in place, an
|
|
`ElasticsearchTemplate` can be injected like any other Spring bean,
|
|
as shown in the following example:
|
|
|
|
include::code:MyBean[]
|
|
|
|
In the presence of `spring-data-elasticsearch` and Reactor, Spring Boot can also auto-configure a <<features#data.nosql.elasticsearch.connecting-using-rest.reactiveclient,ReactiveElasticsearchClient>> and a `ReactiveElasticsearchTemplate` as beans.
|
|
They are the reactive equivalent of the other REST clients.
|
|
|
|
|
|
|
|
[[data.nosql.elasticsearch.repositories]]
|
|
==== Spring Data Elasticsearch Repositories
|
|
Spring Data includes repository support for Elasticsearch.
|
|
As with the JPA repositories discussed earlier, the basic principle is that queries are constructed for you automatically based on method names.
|
|
|
|
In fact, both Spring Data JPA and Spring Data Elasticsearch share the same common infrastructure.
|
|
You could take the JPA example from earlier and, assuming that `City` is now an Elasticsearch `@Document` class rather than a JPA `@Entity`, it works in the same way.
|
|
|
|
TIP: For complete details of Spring Data Elasticsearch, see the {spring-data-elasticsearch-docs}[reference documentation].
|
|
|
|
Spring Boot supports both classic and reactive Elasticsearch repositories, using the `ElasticsearchRestTemplate` or `ReactiveElasticsearchTemplate` beans.
|
|
Most likely those beans are auto-configured by Spring Boot given the required dependencies are present.
|
|
|
|
If you wish to use your own template for backing the Elasticsearch repositories, you can add your own `ElasticsearchRestTemplate` or `ElasticsearchOperations` `@Bean`, as long as it is named `"elasticsearchTemplate"`.
|
|
Same applies to `ReactiveElasticsearchTemplate` and `ReactiveElasticsearchOperations`, with the bean name `"reactiveElasticsearchTemplate"`.
|
|
|
|
You can choose to disable the repositories support with the following property:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
data:
|
|
elasticsearch:
|
|
repositories:
|
|
enabled: false
|
|
----
|
|
|
|
|
|
|
|
[[data.nosql.cassandra]]
|
|
=== Cassandra
|
|
https://cassandra.apache.org/[Cassandra] is an open source, distributed database management system designed to handle large amounts of data across many commodity servers.
|
|
Spring Boot offers auto-configuration for Cassandra and the abstractions on top of it provided by https://github.com/spring-projects/spring-data-cassandra[Spring Data Cassandra].
|
|
There is a `spring-boot-starter-data-cassandra` "`Starter`" for collecting the dependencies in a convenient way.
|
|
|
|
|
|
|
|
[[data.nosql.cassandra.connecting]]
|
|
==== Connecting to Cassandra
|
|
You can inject an auto-configured `CassandraTemplate` or a Cassandra `CqlSession` instance as you would with any other Spring Bean.
|
|
The `spring.cassandra.*` properties can be used to customize the connection.
|
|
Generally, you provide `keyspace-name` and `contact-points` as well the local datacenter name, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
cassandra:
|
|
keyspace-name: "mykeyspace"
|
|
contact-points: "cassandrahost1:9042,cassandrahost2:9042"
|
|
local-datacenter: "datacenter1"
|
|
----
|
|
|
|
If the port is the same for all your contact points you can use a shortcut and only specify the host names, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
cassandra:
|
|
keyspace-name: "mykeyspace"
|
|
contact-points: "cassandrahost1,cassandrahost2"
|
|
local-datacenter: "datacenter1"
|
|
----
|
|
|
|
TIP: Those two examples are identical as the port default to `9042`.
|
|
If you need to configure the port, use `spring.cassandra.port`.
|
|
|
|
[NOTE]
|
|
====
|
|
The Cassandra driver has its own configuration infrastructure that loads an `application.conf` at the root of the classpath.
|
|
|
|
Spring Boot does not look for such a file by default but can load one using `spring.cassandra.config`.
|
|
If a property is both present in `+spring.cassandra.*+` and the configuration file, the value in `+spring.cassandra.*+` takes precedence.
|
|
|
|
For more advanced driver customizations, you can register an arbitrary number of beans that implement `DriverConfigLoaderBuilderCustomizer`.
|
|
The `CqlSession` can be customized with a bean of type `CqlSessionBuilderCustomizer`.
|
|
====
|
|
|
|
NOTE: If you use `CqlSessionBuilder` to create multiple `CqlSession` beans, keep in mind the builder is mutable so make sure to inject a fresh copy for each session.
|
|
|
|
The following code listing shows how to inject a Cassandra bean:
|
|
|
|
include::code:MyBean[]
|
|
|
|
If you add your own `@Bean` of type `CassandraTemplate`, it replaces the default.
|
|
|
|
|
|
|
|
[[data.nosql.cassandra.repositories]]
|
|
==== Spring Data Cassandra Repositories
|
|
Spring Data includes basic repository support for Cassandra.
|
|
Currently, this is more limited than the JPA repositories discussed earlier and needs to annotate finder methods with `@Query`.
|
|
|
|
TIP: For complete details of Spring Data Cassandra, see the https://docs.spring.io/spring-data/cassandra/docs/[reference documentation].
|
|
|
|
|
|
|
|
[[data.nosql.couchbase]]
|
|
=== Couchbase
|
|
https://www.couchbase.com/[Couchbase] is an open-source, distributed, multi-model NoSQL document-oriented database that is optimized for interactive applications.
|
|
Spring Boot offers auto-configuration for Couchbase and the abstractions on top of it provided by https://github.com/spring-projects/spring-data-couchbase[Spring Data Couchbase].
|
|
There are `spring-boot-starter-data-couchbase` and `spring-boot-starter-data-couchbase-reactive` "`Starters`" for collecting the dependencies in a convenient way.
|
|
|
|
|
|
|
|
[[data.nosql.couchbase.connecting]]
|
|
==== Connecting to Couchbase
|
|
You can get a `Cluster` by adding the Couchbase SDK and some configuration.
|
|
The `spring.couchbase.*` properties can be used to customize the connection.
|
|
Generally, you provide the https://github.com/couchbaselabs/sdk-rfcs/blob/master/rfc/0011-connection-string.md[connection string], username, and password, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
couchbase:
|
|
connection-string: "couchbase://192.168.1.123"
|
|
username: "user"
|
|
password: "secret"
|
|
----
|
|
|
|
It is also possible to customize some of the `ClusterEnvironment` settings.
|
|
For instance, the following configuration changes the timeout to use to open a new `Bucket` and enables SSL support:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
couchbase:
|
|
env:
|
|
timeouts:
|
|
connect: "3s"
|
|
ssl:
|
|
key-store: "/location/of/keystore.jks"
|
|
key-store-password: "secret"
|
|
----
|
|
|
|
TIP: Check the `spring.couchbase.env.*` properties for more details.
|
|
To take more control, one or more `ClusterEnvironmentBuilderCustomizer` beans can be used.
|
|
|
|
|
|
|
|
[[data.nosql.couchbase.repositories]]
|
|
==== Spring Data Couchbase Repositories
|
|
Spring Data includes repository support for Couchbase.
|
|
For complete details of Spring Data Couchbase, see the {spring-data-couchbase-docs}[reference documentation].
|
|
|
|
You can inject an auto-configured `CouchbaseTemplate` instance as you would with any other Spring Bean, provided a `CouchbaseClientFactory` bean is available.
|
|
This happens when a `Cluster` is available, as described above, and a bucket name has been specified:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
data:
|
|
couchbase:
|
|
bucket-name: "my-bucket"
|
|
----
|
|
|
|
The following examples shows how to inject a `CouchbaseTemplate` bean:
|
|
|
|
include::code:MyBean[]
|
|
|
|
There are a few beans that you can define in your own configuration to override those provided by the auto-configuration:
|
|
|
|
* A `CouchbaseMappingContext` `@Bean` with a name of `couchbaseMappingContext`.
|
|
* A `CustomConversions` `@Bean` with a name of `couchbaseCustomConversions`.
|
|
* A `CouchbaseTemplate` `@Bean` with a name of `couchbaseTemplate`.
|
|
|
|
To avoid hard-coding those names in your own config, you can reuse `BeanNames` provided by Spring Data Couchbase.
|
|
For instance, you can customize the converters to use, as follows:
|
|
|
|
include::code:MyCouchbaseConfiguration[]
|
|
|
|
|
|
|
|
[[data.nosql.ldap]]
|
|
=== LDAP
|
|
https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol[LDAP] (Lightweight Directory Access Protocol) is an open, vendor-neutral, industry standard application protocol for accessing and maintaining distributed directory information services over an IP network.
|
|
Spring Boot offers auto-configuration for any compliant LDAP server as well as support for the embedded in-memory LDAP server from https://ldap.com/unboundid-ldap-sdk-for-java/[UnboundID].
|
|
|
|
LDAP abstractions are provided by https://github.com/spring-projects/spring-data-ldap[Spring Data LDAP].
|
|
There is a `spring-boot-starter-data-ldap` "`Starter`" for collecting the dependencies in a convenient way.
|
|
|
|
|
|
|
|
[[data.nosql.ldap.connecting]]
|
|
==== Connecting to an LDAP Server
|
|
To connect to an LDAP server, make sure you declare a dependency on the `spring-boot-starter-data-ldap` "`Starter`" or `spring-ldap-core` and then declare the URLs of your server in your application.properties, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
ldap:
|
|
urls: "ldap://myserver:1235"
|
|
username: "admin"
|
|
password: "secret"
|
|
----
|
|
|
|
If you need to customize connection settings, you can use the `spring.ldap.base` and `spring.ldap.base-environment` properties.
|
|
|
|
An `LdapContextSource` is auto-configured based on these settings.
|
|
If a `DirContextAuthenticationStrategy` bean is available, it is associated to the auto-configured `LdapContextSource`.
|
|
If you need to customize it, for instance to use a `PooledContextSource`, you can still inject the auto-configured `LdapContextSource`.
|
|
Make sure to flag your customized `ContextSource` as `@Primary` so that the auto-configured `LdapTemplate` uses it.
|
|
|
|
|
|
|
|
[[data.nosql.ldap.repositories]]
|
|
==== Spring Data LDAP Repositories
|
|
Spring Data includes repository support for LDAP.
|
|
For complete details of Spring Data LDAP, see the https://docs.spring.io/spring-data/ldap/docs/1.0.x/reference/html/[reference documentation].
|
|
|
|
You can also inject an auto-configured `LdapTemplate` instance as you would with any other Spring Bean, as shown in the following example:
|
|
|
|
|
|
include::code:MyBean[]
|
|
|
|
|
|
|
|
[[data.nosql.ldap.embedded]]
|
|
==== Embedded In-memory LDAP Server
|
|
For testing purposes, Spring Boot supports auto-configuration of an in-memory LDAP server from https://ldap.com/unboundid-ldap-sdk-for-java/[UnboundID].
|
|
To configure the server, add a dependency to `com.unboundid:unboundid-ldapsdk` and declare a configprop:spring.ldap.embedded.base-dn[] property, as follows:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
ldap:
|
|
embedded:
|
|
base-dn: "dc=spring,dc=io"
|
|
----
|
|
|
|
[NOTE]
|
|
====
|
|
It is possible to define multiple base-dn values, however, since distinguished names usually contain commas, they must be defined using the correct notation.
|
|
|
|
In yaml files, you can use the yaml list notation. In properties files, you must include the index as part of the property name:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring.ldap.embedded.base-dn:
|
|
- "dc=spring,dc=io"
|
|
- "dc=pivotal,dc=io"
|
|
----
|
|
====
|
|
|
|
By default, the server starts on a random port and triggers the regular LDAP support.
|
|
There is no need to specify a configprop:spring.ldap.urls[] property.
|
|
|
|
If there is a `schema.ldif` file on your classpath, it is used to initialize the server.
|
|
If you want to load the initialization script from a different resource, you can also use the configprop:spring.ldap.embedded.ldif[] property.
|
|
|
|
By default, a standard schema is used to validate `LDIF` files.
|
|
You can turn off validation altogether by setting the configprop:spring.ldap.embedded.validation.enabled[] property.
|
|
If you have custom attributes, you can use configprop:spring.ldap.embedded.validation.schema[] to define your custom attribute types or object classes.
|
|
|
|
|
|
|
|
[[data.nosql.influxdb]]
|
|
=== InfluxDB
|
|
https://www.influxdata.com/[InfluxDB] is an open-source time series database optimized for fast, high-availability storage and retrieval of time series data in fields such as operations monitoring, application metrics, Internet-of-Things sensor data, and real-time analytics.
|
|
|
|
|
|
|
|
[[data.nosql.influxdb.connecting]]
|
|
==== Connecting to InfluxDB
|
|
Spring Boot auto-configures an `InfluxDB` instance, provided the `influxdb-java` client is on the classpath and the URL of the database is set, as shown in the following example:
|
|
|
|
[source,yaml,indent=0,subs="verbatim",configprops,configblocks]
|
|
----
|
|
spring:
|
|
influx:
|
|
url: "https://172.0.0.1:8086"
|
|
----
|
|
|
|
If the connection to InfluxDB requires a user and password, you can set the `spring.influx.user` and `spring.influx.password` properties accordingly.
|
|
|
|
InfluxDB relies on OkHttp.
|
|
If you need to tune the http client `InfluxDB` uses behind the scenes, you can register an `InfluxDbOkHttpClientBuilderProvider` bean.
|
|
|
|
If you need more control over the configuration, consider registering an `InfluxDbCustomizer` bean.
|