org.springframework.data.elasticsearch.core

Class ReactiveElasticsearchTemplate

java.lang.Object

org.springframework.data.elasticsearch.core.ReactiveElasticsearchTemplate

All Implemented Interfaces:

Aware, ApplicationContextAware, ReactiveDocumentOperations, ReactiveElasticsearchOperations, ReactiveSearchOperations

public class ReactiveElasticsearchTemplate
extends Object
implements ReactiveElasticsearchOperations, ApplicationContextAware

Since:

3.2

Author:

Christoph Strobl, Mark Paluch, Farid Azaza, Martin Choraine, Peter-Josef Meisch, Mathias Teier, Aleksei Arsenev, Roman Puchkovskiy, Russell Parry, Thomas Geese

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static interface	ReactiveElasticsearchTemplate.DocumentCallback<T>
protected class	ReactiveElasticsearchTemplate.ReadDocumentCallback<T>
protected class	ReactiveElasticsearchTemplate.ReadSearchDocumentCallback<T>
protected static interface	ReactiveElasticsearchTemplate.SearchDocumentCallback<T>

Nested classes/interfaces inherited from interface org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations

ReactiveElasticsearchOperations.ClientCallback<T extends org.reactivestreams.Publisher<?>>, ReactiveElasticsearchOperations.IndicesClientCallback<T extends org.reactivestreams.Publisher<?>>

Field Summary

Fields

Modifier and Type	Field and Description
protected org.springframework.data.elasticsearch.core.RequestFactory	requestFactory

Constructor Summary

Constructors

Constructor and Description
ReactiveElasticsearchTemplate(ReactiveElasticsearchClient client)
ReactiveElasticsearchTemplate(ReactiveElasticsearchClient client, ElasticsearchConverter converter)

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Flux<org.elasticsearch.search.aggregations.Aggregation>	aggregate(Query query, Class<?> entityType) Perform an aggregation specified by the given query.
reactor.core.publisher.Flux<org.elasticsearch.search.aggregations.Aggregation>	aggregate(Query query, Class<?> entityType, IndexCoordinates index) Perform an aggregation specified by the given query.
reactor.core.publisher.Mono<Void>	bulkUpdate(List<UpdateQuery> queries, BulkOptions bulkOptions, IndexCoordinates index) Bulk update all objects.
protected reactor.core.publisher.Mono<org.elasticsearch.action.bulk.BulkResponse>	checkForBulkOperationFailure(org.elasticsearch.action.bulk.BulkResponse bulkResponse)
reactor.core.publisher.Mono<Long>	count(Query query, Class<?> entityType) Count the number of documents matching the given Query.
reactor.core.publisher.Mono<Long>	count(Query query, Class<?> entityType, IndexCoordinates index) Count the number of documents matching the given Query.
reactor.core.publisher.Mono<String>	delete(Object entity) Delete the given entity extracting index from entity metadata.
reactor.core.publisher.Mono<String>	delete(Object entity, IndexCoordinates index) Delete the given entity extracting index from entity metadata.
reactor.core.publisher.Mono<Long>	delete(Query query, Class<?> entityType) Delete the documents matching the given Query extracting index from entity metadata.
reactor.core.publisher.Mono<Long>	delete(Query query, Class<?> entityType, IndexCoordinates index) Delete the documents matching the given Query extracting index from entity metadata.
reactor.core.publisher.Mono<String>	delete(String id, Class<?> entityType) Delete the entity with given id extracting index from entity metadata.
reactor.core.publisher.Mono<String>	delete(String id, IndexCoordinates index) Delete the entity with given id.
protected reactor.core.publisher.Flux<org.elasticsearch.search.aggregations.Aggregation>	doAggregate(org.elasticsearch.action.search.SearchRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Flux<org.elasticsearch.action.bulk.BulkItemResponse>	doBulkOperation(List<?> queries, BulkOptions bulkOptions, IndexCoordinates index)
protected reactor.core.publisher.Mono<Long>	doCount(org.elasticsearch.action.search.SearchRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Mono<String>	doDelete(org.elasticsearch.action.delete.DeleteRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Mono<org.elasticsearch.index.reindex.BulkByScrollResponse>	doDeleteBy(org.elasticsearch.index.reindex.DeleteByQueryRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Mono<Boolean>	doExists(org.elasticsearch.action.get.GetRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Flux<SearchDocument>	doFind(org.elasticsearch.action.search.SearchRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Mono<SearchDocumentResponse>	doFindForResponse(org.elasticsearch.action.search.SearchRequest request) Customization hook on the actual execution result Mono.
protected reactor.core.publisher.Mono<org.elasticsearch.index.get.GetResult>	doGet(org.elasticsearch.action.get.GetRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Mono<org.elasticsearch.action.index.IndexResponse>	doIndex(org.elasticsearch.action.index.IndexRequest request) Customization hook on the actual execution result Publisher.
protected reactor.core.publisher.Flux<SearchDocument>	doScroll(org.elasticsearch.action.search.SearchRequest request) Customization hook on the actual execution result Publisher.
<T> org.reactivestreams.Publisher<T>	execute(ReactiveElasticsearchOperations.ClientCallback<org.reactivestreams.Publisher<T>> callback) Execute within a ReactiveElasticsearchOperations.ClientCallback managing resources and translating errors.
<T> org.reactivestreams.Publisher<T>	executeWithIndicesClient(ReactiveElasticsearchOperations.IndicesClientCallback<org.reactivestreams.Publisher<T>> callback) Execute within a ReactiveElasticsearchOperations.IndicesClientCallback managing resources and translating errors.
reactor.core.publisher.Mono<Boolean>	exists(String id, Class<?> entityType) Check if an entity with given id exists.
reactor.core.publisher.Mono<Boolean>	exists(String id, Class<?> entityType, IndexCoordinates index) Check if an entity with given id exists.
reactor.core.publisher.Mono<Boolean>	exists(String id, IndexCoordinates index) Check if an entity with given id exists.
<T> reactor.core.publisher.Mono<T>	get(String id, Class<T> entityType) Find the document with the given id mapped onto the given entityType.
<T> reactor.core.publisher.Mono<T>	get(String id, Class<T> entityType, IndexCoordinates index) Fetch the entity with given id.
protected ReactiveElasticsearchClient	getClient() Obtain the ReactiveElasticsearchClient to operate upon.
protected reactor.core.publisher.Mono<String>	getClusterVersion()
ElasticsearchConverter	getElasticsearchConverter() Get the ElasticsearchConverter used.
IndexCoordinates	getIndexCoordinatesFor(Class<?> clazz)
protected ReactiveElasticsearchClient.Indices	getIndicesClient() Obtain the ReactiveElasticsearchClient.Indices to operate upon.
ElasticsearchPersistentEntity<?>	getPersistentEntityFor(Class<?> type)
org.elasticsearch.action.support.WriteRequest.RefreshPolicy	getRefreshPolicy()
ReactiveIndexOperations	indexOps(Class<?> clazz) Creates a ReactiveIndexOperations that is bound to the given class
ReactiveIndexOperations	indexOps(IndexCoordinates index) Creates a ReactiveIndexOperations that is bound to the given index
protected <T> reactor.core.publisher.Mono<T>	maybeCallAfterConvert(T entity, Document document, IndexCoordinates index)
protected <T> reactor.core.publisher.Mono<T>	maybeCallAfterSave(T entity, IndexCoordinates index)
protected <T> reactor.core.publisher.Mono<T>	maybeCallBeforeConvert(T entity, IndexCoordinates index)
<T> reactor.core.publisher.Flux<T>	multiGet(Query query, Class<T> clazz) Execute a multiGet against elasticsearch for the given ids.
<T> reactor.core.publisher.Flux<T>	multiGet(Query query, Class<T> clazz, IndexCoordinates index) Execute a multiGet against elasticsearch for the given ids.
protected org.elasticsearch.index.reindex.DeleteByQueryRequest	prepareDeleteByRequest(org.elasticsearch.index.reindex.DeleteByQueryRequest request) Customization hook to modify a generated DeleteByQueryRequest prior to its execution.
protected org.elasticsearch.action.delete.DeleteRequest	prepareDeleteRequest(org.elasticsearch.action.delete.DeleteRequest request) Customization hook to modify a generated DeleteRequest prior to its execution.
protected org.elasticsearch.action.index.IndexRequest	prepareIndexRequest(Object source, org.elasticsearch.action.index.IndexRequest request) Customization hook to modify a generated IndexRequest prior to its execution.
protected org.elasticsearch.action.search.SearchRequest	prepareSearchRequest(org.elasticsearch.action.search.SearchRequest request) Customization hook to modify a generated SearchRequest prior to its execution.
protected <R extends org.elasticsearch.action.support.WriteRequest<R>> R	prepareWriteRequest(R request) Pre process the write request before it is sent to the server, eg. by setting the refresh policy if applicable.
<T> reactor.core.publisher.Mono<T>	save(T entity) Index the given entity extracting index from entity metadata.
<T> reactor.core.publisher.Mono<T>	save(T entity, IndexCoordinates index) Index the entity under the given type in the given index.
<T> reactor.core.publisher.Flux<T>	saveAll(reactor.core.publisher.Mono<? extends Collection<? extends T>> entities, Class<T> clazz) Index entities in the index extracted from entity metadata.
<T> reactor.core.publisher.Flux<T>	saveAll(reactor.core.publisher.Mono<? extends Collection<? extends T>> entitiesPublisher, IndexCoordinates index) Index entities in the given index.
<T> reactor.core.publisher.Flux<SearchHit<T>>	search(Query query, Class<?> entityType, Class<T> returnType) Search the index for entities matching the given query.
<T> reactor.core.publisher.Flux<SearchHit<T>>	search(Query query, Class<?> entityType, Class<T> resultType, IndexCoordinates index) Search the index for entities matching the given query.
<T> reactor.core.publisher.Mono<SearchPage<T>>	searchForPage(Query query, Class<?> entityType, Class<T> resultType) Search the index for entities matching the given query.
<T> reactor.core.publisher.Mono<SearchPage<T>>	searchForPage(Query query, Class<?> entityType, Class<T> resultType, IndexCoordinates index) Search the index for entities matching the given query.
void	setApplicationContext(ApplicationContext applicationContext)
void	setEntityCallbacks(ReactiveEntityCallbacks entityCallbacks) Set the ReactiveEntityCallbacks instance to use when invoking callbacks like the ReactiveBeforeConvertCallback.
void	setIndicesOptions(org.elasticsearch.action.support.IndicesOptions indicesOptions) Set the default IndicesOptions for search requests.
void	setRefreshPolicy(org.elasticsearch.action.support.WriteRequest.RefreshPolicy refreshPolicy) Set the default WriteRequest.RefreshPolicy to apply when writing to Elasticsearch.
reactor.core.publisher.Flux<org.elasticsearch.search.suggest.Suggest>	suggest(org.elasticsearch.search.suggest.SuggestBuilder suggestion, Class<?> entityType) Does a suggest query
reactor.core.publisher.Flux<org.elasticsearch.search.suggest.Suggest>	suggest(org.elasticsearch.search.suggest.SuggestBuilder suggestion, IndexCoordinates index) Does a suggest query
reactor.core.publisher.Mono<UpdateResponse>	update(UpdateQuery updateQuery, IndexCoordinates index) Partial update of the document.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.springframework.data.elasticsearch.core.ReactiveDocumentOperations

bulkUpdate, delete, findById, findById, save, save, saveAll, saveAll

Methods inherited from interface org.springframework.data.elasticsearch.core.ReactiveSearchOperations

count, find, find, find, find, search, search, searchForPage, searchForPage

Field Detail

requestFactory

protected org.springframework.data.elasticsearch.core.RequestFactory requestFactory

Constructor Detail

ReactiveElasticsearchTemplate

public ReactiveElasticsearchTemplate(ReactiveElasticsearchClient client)

ReactiveElasticsearchTemplate

public ReactiveElasticsearchTemplate(ReactiveElasticsearchClient client,
                                     ElasticsearchConverter converter)

Method Detail

setApplicationContext

public void setApplicationContext(ApplicationContext applicationContext)
                           throws BeansException

Specified by:

setApplicationContext in interface ApplicationContextAware

Throws:

BeansException

setRefreshPolicy

public void setRefreshPolicy(@Nullable
                             org.elasticsearch.action.support.WriteRequest.RefreshPolicy refreshPolicy)

Set the default WriteRequest.RefreshPolicy to apply when writing to Elasticsearch.

Parameters:

refreshPolicy - can be null.

getRefreshPolicy

@Nullable
public org.elasticsearch.action.support.WriteRequest.RefreshPolicy getRefreshPolicy()

Returns:

the current WriteRequest.RefreshPolicy.

setIndicesOptions

public void setIndicesOptions(@Nullable
                              org.elasticsearch.action.support.IndicesOptions indicesOptions)

Set the default IndicesOptions for search requests.

Parameters:

indicesOptions - can be null.

setEntityCallbacks

public void setEntityCallbacks(ReactiveEntityCallbacks entityCallbacks)

Set the ReactiveEntityCallbacks instance to use when invoking callbacks like the ReactiveBeforeConvertCallback.

Overrides potentially existing ReactiveEntityCallbacks.

Parameters:

entityCallbacks - must not be null.

Throws:

IllegalArgumentException - if the given instance is null.

Since:

4.0

save

public <T> reactor.core.publisher.Mono<T> save(T entity,
                                               IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Index the entity under the given type in the given index. If the index is null or empty the index name provided via entity metadata is used. Same for the type.

Specified by:

save in interface ReactiveDocumentOperations

Parameters:

entity - must not be null.

index - the target index, must not be null

Returns:

a Mono emitting the saved entity.

save

public <T> reactor.core.publisher.Mono<T> save(T entity)

Description copied from interface: ReactiveDocumentOperations

Index the given entity extracting index from entity metadata.

Specified by:

save in interface ReactiveDocumentOperations

Parameters:

entity - must not be null.

Returns:

a Mono emitting the saved entity.

saveAll

public <T> reactor.core.publisher.Flux<T> saveAll(reactor.core.publisher.Mono<? extends Collection<? extends T>> entities,
                                                  Class<T> clazz)

Description copied from interface: ReactiveDocumentOperations

Index entities in the index extracted from entity metadata.

Specified by:

saveAll in interface ReactiveDocumentOperations

Parameters:

entities - must not be null.

clazz - the entity class, used to determine the index

Returns:

a Flux emitting saved entities.

saveAll

public <T> reactor.core.publisher.Flux<T> saveAll(reactor.core.publisher.Mono<? extends Collection<? extends T>> entitiesPublisher,
                                                  IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Index entities in the given index. If the index is null or empty the index name provided via entity metadata is used.

Specified by:

saveAll in interface ReactiveDocumentOperations

Parameters:

entitiesPublisher - must not be null.

index - the target index, must not be null

Returns:

a Flux emitting saved entities.

multiGet

public <T> reactor.core.publisher.Flux<T> multiGet(Query query,
                                                   Class<T> clazz)

Description copied from interface: ReactiveDocumentOperations

Execute a multiGet against elasticsearch for the given ids.

Specified by:

multiGet in interface ReactiveDocumentOperations

Parameters:

query - the query defining the ids of the objects to get

clazz - the type of the object to be returned, used to determine the index

Returns:

flux with list of nullable objects

multiGet

public <T> reactor.core.publisher.Flux<T> multiGet(Query query,
                                                   Class<T> clazz,
                                                   IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Execute a multiGet against elasticsearch for the given ids.

Specified by:

multiGet in interface ReactiveDocumentOperations

Parameters:

query - the query defining the ids of the objects to get

clazz - the type of the object to be returned

index - the index(es) from which the objects are read.

Returns:

flux with list of nullable objects

bulkUpdate

public reactor.core.publisher.Mono<Void> bulkUpdate(List<UpdateQuery> queries,
                                                    BulkOptions bulkOptions,
                                                    IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Bulk update all objects. Will do update.

Specified by:

bulkUpdate in interface ReactiveDocumentOperations

Parameters:

queries - the queries to execute in bulk

bulkOptions - options to be added to the bulk request

doIndex

protected reactor.core.publisher.Mono<org.elasticsearch.action.index.IndexResponse> doIndex(org.elasticsearch.action.index.IndexRequest request)

Customization hook on the actual execution result Publisher.
You know what you're doing here? Well fair enough, go ahead on your own risk.

Parameters:

request - the already prepared IndexRequest ready to be executed.

Returns:

a Mono emitting the result of the operation.

doBulkOperation

protected reactor.core.publisher.Flux<org.elasticsearch.action.bulk.BulkItemResponse> doBulkOperation(List<?> queries,
                                                                                                      BulkOptions bulkOptions,
                                                                                                      IndexCoordinates index)

checkForBulkOperationFailure

protected reactor.core.publisher.Mono<org.elasticsearch.action.bulk.BulkResponse> checkForBulkOperationFailure(org.elasticsearch.action.bulk.BulkResponse bulkResponse)

exists

public reactor.core.publisher.Mono<Boolean> exists(String id,
                                                   Class<?> entityType)

Description copied from interface: ReactiveDocumentOperations

Check if an entity with given id exists.

Specified by:

exists in interface ReactiveDocumentOperations

Parameters:

id - the _id of the document to look for.

entityType - the domain type used.

Returns:

a Mono emitting true if a matching document exists, false otherwise.

exists

public reactor.core.publisher.Mono<Boolean> exists(String id,
                                                   IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Check if an entity with given id exists.

Specified by:

exists in interface ReactiveDocumentOperations

Parameters:

id - the _id of the document to look for.

index - the target index, must not be null

Returns:

a Mono emitting true if a matching document exists, false otherwise.

exists

public reactor.core.publisher.Mono<Boolean> exists(String id,
                                                   Class<?> entityType,
                                                   IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Check if an entity with given id exists.

Specified by:

exists in interface ReactiveDocumentOperations

Parameters:

id - the _id of the document to look for.

index - the target index, must not be null

Returns:

a Mono emitting true if a matching document exists, false otherwise.

doExists

protected reactor.core.publisher.Mono<Boolean> doExists(org.elasticsearch.action.get.GetRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared GetRequest ready to be executed.

Returns:

a Mono emitting the result of the operation.

get

public <T> reactor.core.publisher.Mono<T> get(String id,
                                              Class<T> entityType)

Description copied from interface: ReactiveDocumentOperations

Find the document with the given id mapped onto the given entityType.

Specified by:

get in interface ReactiveDocumentOperations

Parameters:

id - the _id of the document to fetch.

entityType - the domain type used for mapping the document.

Returns:

Mono.empty() if not found.

get

public <T> reactor.core.publisher.Mono<T> get(String id,
                                              Class<T> entityType,
                                              IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Fetch the entity with given id.

Specified by:

get in interface ReactiveDocumentOperations

Parameters:

id - must not be null.

index - the target index, must not be null

Returns:

the Mono emitting the entity or signalling completion if none found.

doGet

protected reactor.core.publisher.Mono<org.elasticsearch.index.get.GetResult> doGet(org.elasticsearch.action.get.GetRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared GetRequest ready to be executed.

Returns:

a Mono emitting the result of the operation.

delete

public reactor.core.publisher.Mono<String> delete(Object entity,
                                                  IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Delete the given entity extracting index from entity metadata.

Specified by:

delete in interface ReactiveDocumentOperations

Parameters:

entity - must not be null.

index - the target index, must not be null

Returns:

a Mono emitting the id of the removed document.

delete

public reactor.core.publisher.Mono<String> delete(Object entity)

Description copied from interface: ReactiveDocumentOperations

Delete the given entity extracting index from entity metadata.

Specified by:

delete in interface ReactiveDocumentOperations

Parameters:

entity - must not be null.

Returns:

a Mono emitting the id of the removed document.

delete

public reactor.core.publisher.Mono<String> delete(String id,
                                                  Class<?> entityType)

Description copied from interface: ReactiveDocumentOperations

Delete the entity with given id extracting index from entity metadata.

Specified by:

delete in interface ReactiveDocumentOperations

Parameters:

id - must not be null.

entityType - must not be null.

Returns:

a Mono emitting the id of the removed document.

delete

public reactor.core.publisher.Mono<String> delete(String id,
                                                  IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Delete the entity with given id.

Specified by:

delete in interface ReactiveDocumentOperations

Parameters:

id - must not be null.

index - the target index, must not be null

Returns:

a Mono emitting the id of the removed document.

delete

public reactor.core.publisher.Mono<Long> delete(Query query,
                                                Class<?> entityType,
                                                IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Delete the documents matching the given Query extracting index from entity metadata.

Specified by:

delete in interface ReactiveDocumentOperations

Parameters:

query - must not be null.

entityType - must not be null.

index - the target index, must not be null

Returns:

a Mono emitting the number of the removed documents.

update

public reactor.core.publisher.Mono<UpdateResponse> update(UpdateQuery updateQuery,
                                                          IndexCoordinates index)

Description copied from interface: ReactiveDocumentOperations

Partial update of the document.

Specified by:

update in interface ReactiveDocumentOperations

Parameters:

updateQuery - query defining the update

index - the index where to update the records

Returns:

a Mono emitting the update response

delete

public reactor.core.publisher.Mono<Long> delete(Query query,
                                                Class<?> entityType)

Description copied from interface: ReactiveDocumentOperations

Delete the documents matching the given Query extracting index from entity metadata.

Specified by:

delete in interface ReactiveDocumentOperations

Parameters:

query - must not be null.

entityType - must not be null.

Returns:

a Mono emitting the number of the removed documents.

doDelete

protected reactor.core.publisher.Mono<String> doDelete(org.elasticsearch.action.delete.DeleteRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared DeleteRequest ready to be executed.

Returns:

a Mono emitting the result of the operation.

doDeleteBy

protected reactor.core.publisher.Mono<org.elasticsearch.index.reindex.BulkByScrollResponse> doDeleteBy(org.elasticsearch.index.reindex.DeleteByQueryRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared DeleteByQueryRequest ready to be executed.

Returns:

a Mono emitting the result of the operation.

prepareDeleteRequest

protected org.elasticsearch.action.delete.DeleteRequest prepareDeleteRequest(org.elasticsearch.action.delete.DeleteRequest request)

Customization hook to modify a generated DeleteRequest prior to its execution. Eg. by setting the refresh policy if applicable.

Parameters:

request - the generated DeleteRequest.

Returns:

never null.

prepareDeleteByRequest

protected org.elasticsearch.index.reindex.DeleteByQueryRequest prepareDeleteByRequest(org.elasticsearch.index.reindex.DeleteByQueryRequest request)

Customization hook to modify a generated DeleteByQueryRequest prior to its execution. Eg. by setting the refresh policy if applicable.

Parameters:

request - the generated DeleteByQueryRequest.

Returns:

never null.

prepareIndexRequest

protected org.elasticsearch.action.index.IndexRequest prepareIndexRequest(Object source,
                                                                          org.elasticsearch.action.index.IndexRequest request)

Customization hook to modify a generated IndexRequest prior to its execution. Eg. by setting the refresh policy if applicable.

Parameters:

source - the source object the IndexRequest was derived from.

request - the generated IndexRequest.

Returns:

never null.

prepareWriteRequest

protected <R extends org.elasticsearch.action.support.WriteRequest<R>> R prepareWriteRequest(R request)

Pre process the write request before it is sent to the server, eg. by setting the refresh policy if applicable.

Type Parameters:

R -

Parameters:

request - must not be null.

Returns:

the processed WriteRequest.

search

public <T> reactor.core.publisher.Flux<SearchHit<T>> search(Query query,
                                                            Class<?> entityType,
                                                            Class<T> resultType,
                                                            IndexCoordinates index)

Description copied from interface: ReactiveSearchOperations

Search the index for entities matching the given query.

Specified by:

search in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - must not be null.

resultType - the projection result type.

index - the target index, must not be null

Returns:

a Flux emitting matching entities one by one wrapped in a SearchHit.

search

public <T> reactor.core.publisher.Flux<SearchHit<T>> search(Query query,
                                                            Class<?> entityType,
                                                            Class<T> returnType)

Description copied from interface: ReactiveSearchOperations

Search the index for entities matching the given query.
Unpaged queries may overrule elasticsearch server defaults for page size by either * delegating to the scroll API or using a max * size.

Specified by:

search in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - The entity type for mapping the query. Must not be null.

returnType - The mapping target type. Must not be null. Th

Returns:

a Flux emitting matching entities one by one wrapped in a SearchHit.

searchForPage

public <T> reactor.core.publisher.Mono<SearchPage<T>> searchForPage(Query query,
                                                                    Class<?> entityType,
                                                                    Class<T> resultType)

Description copied from interface: ReactiveSearchOperations

Search the index for entities matching the given query.

Specified by:

searchForPage in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - must not be null.

resultType - the projection result type.

Returns:

a Mono emitting matching entities in a SearchHits.

searchForPage

public <T> reactor.core.publisher.Mono<SearchPage<T>> searchForPage(Query query,
                                                                    Class<?> entityType,
                                                                    Class<T> resultType,
                                                                    IndexCoordinates index)

Description copied from interface: ReactiveSearchOperations

Search the index for entities matching the given query.

Specified by:

searchForPage in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - must not be null.

resultType - the projection result type.

index - the target index, must not be null

Returns:

a Mono emitting matching entities in a SearchHits.

aggregate

public reactor.core.publisher.Flux<org.elasticsearch.search.aggregations.Aggregation> aggregate(Query query,
                                                                                                Class<?> entityType)

Description copied from interface: ReactiveSearchOperations

Perform an aggregation specified by the given query.

Specified by:

aggregate in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - must not be null.

Returns:

a Flux emitting matching aggregations one by one.

aggregate

public reactor.core.publisher.Flux<org.elasticsearch.search.aggregations.Aggregation> aggregate(Query query,
                                                                                                Class<?> entityType,
                                                                                                IndexCoordinates index)

Description copied from interface: ReactiveSearchOperations

Perform an aggregation specified by the given query.

Specified by:

aggregate in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - must not be null.

index - the target index, must not be null

Returns:

a Flux emitting matching aggregations one by one.

suggest

public reactor.core.publisher.Flux<org.elasticsearch.search.suggest.Suggest> suggest(org.elasticsearch.search.suggest.SuggestBuilder suggestion,
                                                                                     Class<?> entityType)

Description copied from interface: ReactiveSearchOperations

Does a suggest query

Specified by:

suggest in interface ReactiveSearchOperations

Parameters:

suggestion - the query

entityType - must not be null.

Returns:

the suggest response

suggest

public reactor.core.publisher.Flux<org.elasticsearch.search.suggest.Suggest> suggest(org.elasticsearch.search.suggest.SuggestBuilder suggestion,
                                                                                     IndexCoordinates index)

Description copied from interface: ReactiveSearchOperations

Does a suggest query

Specified by:

suggest in interface ReactiveSearchOperations

Parameters:

suggestion - the query

index - the index to run the query against

Returns:

the suggest response

count

public reactor.core.publisher.Mono<Long> count(Query query,
                                               Class<?> entityType)

Description copied from interface: ReactiveSearchOperations

Count the number of documents matching the given Query.

Specified by:

count in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - must not be null.

Returns:

a Mono emitting the nr of matching documents.

count

public reactor.core.publisher.Mono<Long> count(Query query,
                                               Class<?> entityType,
                                               IndexCoordinates index)

Description copied from interface: ReactiveSearchOperations

Count the number of documents matching the given Query.

Specified by:

count in interface ReactiveSearchOperations

Parameters:

query - must not be null.

entityType - must not be null.

index - the target index, must not be null

Returns:

a Mono emitting the nr of matching documents.

doFind

protected reactor.core.publisher.Flux<SearchDocument> doFind(org.elasticsearch.action.search.SearchRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared SearchRequest ready to be executed.

Returns:

a Flux emitting the result of the operation converted to SearchDocuments.

doFindForResponse

protected reactor.core.publisher.Mono<SearchDocumentResponse> doFindForResponse(org.elasticsearch.action.search.SearchRequest request)

Customization hook on the actual execution result Mono.

Parameters:

request - the already prepared SearchRequest ready to be executed.

Returns:

a Mono emitting the result of the operation converted to s SearchDocumentResponse.

doAggregate

protected reactor.core.publisher.Flux<org.elasticsearch.search.aggregations.Aggregation> doAggregate(org.elasticsearch.action.search.SearchRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared SearchRequest ready to be executed.

Returns:

a Flux emitting the result of the operation.

doCount

protected reactor.core.publisher.Mono<Long> doCount(org.elasticsearch.action.search.SearchRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared SearchRequest ready to be executed.

Returns:

a Mono emitting the result of the operation.

doScroll

protected reactor.core.publisher.Flux<SearchDocument> doScroll(org.elasticsearch.action.search.SearchRequest request)

Customization hook on the actual execution result Publisher.

Parameters:

request - the already prepared SearchRequest ready to be executed.

Returns:

a Flux emitting the result of the operation converted to SearchDocuments.

prepareSearchRequest

protected org.elasticsearch.action.search.SearchRequest prepareSearchRequest(org.elasticsearch.action.search.SearchRequest request)

Customization hook to modify a generated SearchRequest prior to its execution. Eg. by setting the indices options if applicable.

Parameters:

request - the generated SearchRequest.

Returns:

never null.

getClusterVersion

protected reactor.core.publisher.Mono<String> getClusterVersion()

execute

public <T> org.reactivestreams.Publisher<T> execute(ReactiveElasticsearchOperations.ClientCallback<org.reactivestreams.Publisher<T>> callback)

Description copied from interface: ReactiveElasticsearchOperations

Execute within a ReactiveElasticsearchOperations.ClientCallback managing resources and translating errors.

Specified by:

execute in interface ReactiveElasticsearchOperations

Type Parameters:

T - the type the Publisher emits

Parameters:

callback - must not be null.

Returns:

the Publisher emitting results.

executeWithIndicesClient

public <T> org.reactivestreams.Publisher<T> executeWithIndicesClient(ReactiveElasticsearchOperations.IndicesClientCallback<org.reactivestreams.Publisher<T>> callback)

Description copied from interface: ReactiveElasticsearchOperations

Execute within a ReactiveElasticsearchOperations.IndicesClientCallback managing resources and translating errors.

Specified by:

executeWithIndicesClient in interface ReactiveElasticsearchOperations

Type Parameters:

T - the type the Publisher emits

Parameters:

callback - must not be null.

Returns:

the Publisher emitting results.

getElasticsearchConverter

public ElasticsearchConverter getElasticsearchConverter()

Description copied from interface: ReactiveElasticsearchOperations

Get the ElasticsearchConverter used.

Specified by:

getElasticsearchConverter in interface ReactiveElasticsearchOperations

Returns:

never null

indexOps

public ReactiveIndexOperations indexOps(IndexCoordinates index)

Description copied from interface: ReactiveElasticsearchOperations

Creates a ReactiveIndexOperations that is bound to the given index

Specified by:

indexOps in interface ReactiveElasticsearchOperations

Parameters:

index - IndexCoordinates specifying the index

Returns:

ReactiveIndexOperations implementation

indexOps

public ReactiveIndexOperations indexOps(Class<?> clazz)

Description copied from interface: ReactiveElasticsearchOperations

Creates a ReactiveIndexOperations that is bound to the given class

Specified by:

indexOps in interface ReactiveElasticsearchOperations

Parameters:

clazz - the entity clazz specifiying the index information

Returns:

ReactiveIndexOperations implementation

getIndexCoordinatesFor

public IndexCoordinates getIndexCoordinatesFor(Class<?> clazz)

Specified by:

getIndexCoordinatesFor in interface ReactiveElasticsearchOperations

Returns:

the IndexCoordinates defined on the entity.

getPersistentEntityFor

@Nullable
public ElasticsearchPersistentEntity<?> getPersistentEntityFor(@Nullable
                                                                         Class<?> type)

Specified by:

getPersistentEntityFor in interface ReactiveElasticsearchOperations

getClient

protected ReactiveElasticsearchClient getClient()

Obtain the ReactiveElasticsearchClient to operate upon.

Returns:

never null.

getIndicesClient

protected ReactiveElasticsearchClient.Indices getIndicesClient()

Obtain the ReactiveElasticsearchClient.Indices to operate upon.

Returns:

never null.

maybeCallBeforeConvert

protected <T> reactor.core.publisher.Mono<T> maybeCallBeforeConvert(T entity,
                                                                    IndexCoordinates index)

maybeCallAfterSave

protected <T> reactor.core.publisher.Mono<T> maybeCallAfterSave(T entity,
                                                                IndexCoordinates index)

maybeCallAfterConvert

protected <T> reactor.core.publisher.Mono<T> maybeCallAfterConvert(T entity,
                                                                   Document document,
                                                                   IndexCoordinates index)