org.springframework.data.elasticsearch.core

Class AbstractReactiveElasticsearchTemplate

java.lang.Object

org.springframework.data.elasticsearch.core.AbstractReactiveElasticsearchTemplate

All Implemented Interfaces:

Aware, ApplicationContextAware, ReactiveDocumentOperations, ReactiveElasticsearchOperations, ReactiveSearchOperations

Direct Known Subclasses:

ReactiveElasticsearchTemplate, ReactiveElasticsearchTemplate

public abstract class AbstractReactiveElasticsearchTemplate
extends Object
implements ReactiveElasticsearchOperations, ApplicationContextAware

Base class keeping common code for implementations of the ReactiveElasticsearchOperations interface independent of the used client.

Since:

4.4

Author:

Peter-Josef Meisch

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static interface	AbstractReactiveElasticsearchTemplate.DocumentCallback<T>
protected class	AbstractReactiveElasticsearchTemplate.Entities<T>
static class	AbstractReactiveElasticsearchTemplate.IndexResponseMetaData Value class to capture client independent information from a response to an index request.
protected class	AbstractReactiveElasticsearchTemplate.ReadDocumentCallback<T>
protected class	AbstractReactiveElasticsearchTemplate.ReadSearchDocumentCallback<T>
protected static interface	AbstractReactiveElasticsearchTemplate.SearchDocumentCallback<T>

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

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

Field Summary

Fields

Modifier and Type	Field and Description
protected ElasticsearchConverter	converter
protected ReactiveEntityCallbacks	entityCallbacks
protected EntityOperations	entityOperations
protected SimpleElasticsearchMappingContext	mappingContext
protected static org.slf4j.Logger	QUERY_LOGGER
protected RefreshPolicy	refreshPolicy
protected RoutingResolver	routingResolver

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractReactiveElasticsearchTemplate(ElasticsearchConverter converter)

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Flux<? extends AggregationContainer<?>>	aggregate(Query query, Class<?> entityType) Perform an aggregation specified by the given query.
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<ByQueryResponse>	delete(Query query, Class<?> entityType) 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 abstract AbstractReactiveElasticsearchTemplate	doCopy()
protected abstract reactor.core.publisher.Mono<Long>	doCount(Query query, Class<?> entityType, IndexCoordinates index)
protected abstract reactor.core.publisher.Mono<String>	doDeleteById(String id, String routing, IndexCoordinates index)
protected abstract reactor.core.publisher.Mono<Boolean>	doExists(String id, IndexCoordinates index)
protected abstract reactor.core.publisher.Flux<SearchDocument>	doFind(Query query, Class<?> clazz, IndexCoordinates index)
protected abstract <T> reactor.core.publisher.Mono<SearchDocumentResponse>	doFindForResponse(Query query, Class<?> clazz, IndexCoordinates index)
protected abstract <T> reactor.core.publisher.Mono<reactor.util.function.Tuple2<T,AbstractReactiveElasticsearchTemplate.IndexResponseMetaData>>	doIndex(T entity, IndexCoordinates index)
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, 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.
protected abstract reactor.core.publisher.Mono<String>	getClusterVersion()
ElasticsearchConverter	getElasticsearchConverter() Get the ElasticsearchConverter used.
IndexCoordinates	getIndexCoordinatesFor(Class<?> clazz)
protected IndexQuery	getIndexQuery(Object value)
ElasticsearchPersistentEntity<?>	getPersistentEntityFor(Class<?> type)
RefreshPolicy	getRefreshPolicy()
protected abstract reactor.core.publisher.Mono<String>	getRuntimeLibraryVersion()
protected abstract reactor.core.publisher.Mono<String>	getVendor()
reactor.core.publisher.Mono<Void>	logVersions() logs the versions of the different Elasticsearch components.
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<Document>	maybeCallbackAfterLoad(Document document, Class<T> type, IndexCoordinates index)
protected <T> reactor.core.publisher.Mono<T>	maybeCallBeforeConvert(T entity, IndexCoordinates index)
<T> reactor.core.publisher.Flux<MultiGetItem<T>>	multiGet(Query query, Class<T> clazz) Execute a multiGet against elasticsearch for the given ids.
<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<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<ReactiveSearchHits<T>>	searchForHits(Query query, Class<?> entityType, Class<T> resultType) Perform a search and return the ReactiveSearchHits which contains information about the search results and which will provide the documents by the ReactiveSearchHits.getSearchHits() method.
<T> reactor.core.publisher.Mono<ReactiveSearchHits<T>>	searchForHits(Query query, Class<?> entityType, Class<T> resultType, IndexCoordinates index) Perform a search and return the ReactiveSearchHits which contains information about the search results and which will provide the documents by the ReactiveSearchHits.getSearchHits() method.
<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	setRefreshPolicy(RefreshPolicy refreshPolicy) Set the default RefreshPolicy to apply when writing to Elasticsearch.
reactor.core.publisher.Mono<Suggest>	suggest(Query query, Class<?> entityType) Does a suggest query.
reactor.core.publisher.Mono<Suggest>	suggest(Query query, Class<?> entityType, IndexCoordinates index) Does a suggest query.
protected <T> T	updateIndexedObject(T entity, IndexedObjectInformation indexedObjectInformation)
ReactiveElasticsearchOperations	withRouting(RoutingResolver routingResolver) Returns a copy of this instance with the same configuration, but that uses a different RoutingResolver to obtain routing information.

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.ReactiveElasticsearchOperations

cluster, execute, executeWithClusterClient, executeWithIndicesClient, indexOps, indexOps

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

bulkUpdate, bulkUpdate, delete, get, multiGet, reindex, save, save, saveAll, saveAll, saveAll, submitReindex, update, updateByQuery

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

aggregate, count, idsQuery, matchAllQuery, search, search, searchForHits, searchForHits, searchForPage, searchForPage, suggest, suggest

Field Detail

QUERY_LOGGER

protected static final org.slf4j.Logger QUERY_LOGGER

converter

protected final ElasticsearchConverter converter

mappingContext

protected final SimpleElasticsearchMappingContext mappingContext

entityOperations

protected final EntityOperations entityOperations

refreshPolicy

@Nullable
protected RefreshPolicy refreshPolicy

routingResolver

protected RoutingResolver routingResolver

entityCallbacks

@Nullable
protected ReactiveEntityCallbacks entityCallbacks

Constructor Detail

AbstractReactiveElasticsearchTemplate

protected AbstractReactiveElasticsearchTemplate(@Nullable
                                                ElasticsearchConverter converter)

Method Detail

getElasticsearchConverter

public ElasticsearchConverter getElasticsearchConverter()

Description copied from interface: ReactiveElasticsearchOperations

Get the ElasticsearchConverter used.

Specified by:

getElasticsearchConverter in interface ReactiveElasticsearchOperations

Returns:

never null

doCopy

protected abstract AbstractReactiveElasticsearchTemplate doCopy()

setApplicationContext

public void setApplicationContext(ApplicationContext applicationContext)
                           throws BeansException

Specified by:

setApplicationContext in interface ApplicationContextAware

Throws:

BeansException

setRefreshPolicy

public void setRefreshPolicy(@Nullable
                             RefreshPolicy refreshPolicy)

Set the default RefreshPolicy to apply when writing to Elasticsearch.

Parameters:

refreshPolicy - can be null.

getRefreshPolicy

@Nullable
public RefreshPolicy getRefreshPolicy()

Returns:

the current RefreshPolicy.

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

logVersions

public reactor.core.publisher.Mono<Void> logVersions()

logs the versions of the different Elasticsearch components.

Returns:

a Mono signalling finished execution

Since:

4.3

withRouting

public ReactiveElasticsearchOperations withRouting(RoutingResolver routingResolver)

Description copied from interface: ReactiveElasticsearchOperations

Returns a copy of this instance with the same configuration, but that uses a different RoutingResolver to obtain routing information.

Specified by:

withRouting in interface ReactiveElasticsearchOperations

Parameters:

routingResolver - the RoutingResolver value, must not be null.

Returns:

DocumentOperations instance

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.

getIndexQuery

protected IndexQuery getIndexQuery(Object value)

updateIndexedObject

protected <T> T updateIndexedObject(T entity,
                                    IndexedObjectInformation indexedObjectInformation)

multiGet

public <T> reactor.core.publisher.Flux<MultiGetItem<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 MultiGetItems that contain the entities

See Also:

Query.multiGetQuery(Collection), Query.multiGetQueryWithRouting(List)

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.

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.

doIndex

protected abstract <T> reactor.core.publisher.Mono<reactor.util.function.Tuple2<T,AbstractReactiveElasticsearchTemplate.IndexResponseMetaData>> doIndex(T entity,
                                                                                                                                                        IndexCoordinates index)

doExists

protected abstract reactor.core.publisher.Mono<Boolean> doExists(String id,
                                                                 IndexCoordinates index)

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.

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.

doDeleteById

protected abstract reactor.core.publisher.Mono<String> doDeleteById(String id,
                                                                    @Nullable
                                                                    String routing,
                                                                    IndexCoordinates index)

delete

public reactor.core.publisher.Mono<ByQueryResponse> 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.

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.

searchForHits

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

Description copied from interface: ReactiveSearchOperations

Perform a search and return the ReactiveSearchHits which contains information about the search results and which will provide the documents by the ReactiveSearchHits.getSearchHits() method.

Specified by:

searchForHits in interface ReactiveSearchOperations

Type Parameters:

T - the result type class

Parameters:

query - must not be null.

entityType - must not be null.

resultType - the projection result type.

Returns:

a Mono emitting the ReactiveSearchHits that contains the search result information

searchForHits

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

Description copied from interface: ReactiveSearchOperations

Perform a search and return the ReactiveSearchHits which contains information about the search results and which will provide the documents by the ReactiveSearchHits.getSearchHits() method.

Specified by:

searchForHits in interface ReactiveSearchOperations

Type Parameters:

T - the result type class

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 the ReactiveSearchHits that contains the search result information

doFind

protected abstract reactor.core.publisher.Flux<SearchDocument> doFind(Query query,
                                                                      Class<?> clazz,
                                                                      IndexCoordinates index)

doFindForResponse

protected abstract <T> reactor.core.publisher.Mono<SearchDocumentResponse> doFindForResponse(Query query,
                                                                                             Class<?> clazz,
                                                                                             IndexCoordinates index)

aggregate

public reactor.core.publisher.Flux<? extends AggregationContainer<?>> 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.

suggest

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

Description copied from interface: ReactiveSearchOperations

Does a suggest query.

Specified by:

suggest in interface ReactiveSearchOperations

Parameters:

query - the Query containing the suggest definition. Must be currently a NativeSearchQuery, must not be null.

entityType - the type of the entities that might be returned for a completion suggestion, must not be null.

Returns:

suggest data

suggest

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

Description copied from interface: ReactiveSearchOperations

Does a suggest query.

Specified by:

suggest in interface ReactiveSearchOperations

Parameters:

query - the Query containing the suggest definition. Must be currently a NativeSearchQuery, must not be null.

entityType - the type of the entities that might be returned for a completion suggestion, must not be null.

index - the index to run the query against, must not be null.

Returns:

suggest data

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.

doCount

protected abstract reactor.core.publisher.Mono<Long> doCount(Query query,
                                                             Class<?> entityType,
                                                             IndexCoordinates index)

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)

maybeCallbackAfterLoad

protected <T> reactor.core.publisher.Mono<Document> maybeCallbackAfterLoad(Document document,
                                                                           Class<T> type,
                                                                           IndexCoordinates index)

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

getVendor

protected abstract reactor.core.publisher.Mono<String> getVendor()

Returns:

the vendor name of the used cluster and client library

Since:

4.3

getRuntimeLibraryVersion

protected abstract reactor.core.publisher.Mono<String> getRuntimeLibraryVersion()

Returns:

the version of the used client runtime library.

Since:

4.3

getClusterVersion

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