com.microsoft.azure.spring.data.cosmosdb.core

Class ReactiveCosmosTemplate

java.lang.Object

com.microsoft.azure.spring.data.cosmosdb.core.ReactiveCosmosTemplate

All Implemented Interfaces:

ReactiveCosmosOperations, org.springframework.beans.factory.Aware, org.springframework.context.ApplicationContextAware

public class ReactiveCosmosTemplate
extends Object
implements ReactiveCosmosOperations, org.springframework.context.ApplicationContextAware

Field Summary

Fields

Modifier and Type	Field and Description
private List<String>	containerNameCache
private com.azure.data.cosmos.CosmosClient	cosmosClient
private static String	COUNT_VALUE_KEY
private String	databaseName
private Function<Class<?>,CosmosEntityInformation<?,?>>	entityInfoCreator
private boolean	isPopulateQueryMetrics
private MappingCosmosConverter	mappingCosmosConverter
private ResponseDiagnosticsProcessor	responseDiagnosticsProcessor

Constructor Summary

Constructors

Constructor and Description
ReactiveCosmosTemplate(CosmosDbFactory cosmosDbFactory, MappingCosmosConverter mappingCosmosConverter, String dbName) Constructor

Method Summary

Modifier and Type	Method and Description
private void	applyVersioning(Class<?> domainType, com.azure.data.cosmos.CosmosItemProperties cosmosItemProperties, com.azure.data.cosmos.CosmosItemRequestOptions options)
private void	assertValidId(Object id)
reactor.core.publisher.Mono<Long>	count(DocumentQuery query, boolean isCrossPartitionQuery, String containerName)
reactor.core.publisher.Mono<Long>	count(DocumentQuery query, String containerName) Count
reactor.core.publisher.Mono<Long>	count(String containerName) Count
reactor.core.publisher.Mono<com.azure.data.cosmos.CosmosContainerResponse>	createCollectionIfNotExists(CosmosEntityInformation information) Creates a container if it doesn't already exist
reactor.core.publisher.Mono<com.azure.data.cosmos.CosmosContainerResponse>	createContainerIfNotExists(CosmosEntityInformation information) Creates a container if it doesn't already exist
<T> reactor.core.publisher.Flux<T>	delete(DocumentQuery query, Class<T> domainType, String containerName) Delete items matching query
reactor.core.publisher.Mono<Void>	deleteAll(String containerName, String partitionKeyName) Delete all items in a container
reactor.core.publisher.Mono<Void>	deleteById(String containerName, Object id, com.azure.data.cosmos.PartitionKey partitionKey) Delete an item by id
void	deleteContainer(String containerName) Delete container with container name
private reactor.core.publisher.Mono<com.azure.data.cosmos.CosmosItemProperties>	deleteItem(com.azure.data.cosmos.CosmosItemProperties cosmosItemProperties, List<String> partitionKeyNames, String containerName, Class<?> domainType)
private reactor.core.publisher.Flux<com.azure.data.cosmos.FeedResponse<com.azure.data.cosmos.CosmosItemProperties>>	executeQuery(com.azure.data.cosmos.SqlQuerySpec sqlQuerySpec, String containerName, com.azure.data.cosmos.FeedOptions options)
reactor.core.publisher.Mono<Boolean>	exists(DocumentQuery query, Class<?> domainType, String containerName) Exists
reactor.core.publisher.Mono<Boolean>	existsById(Object id, Class<?> domainType, String containerName) Exists
<T> reactor.core.publisher.Flux<T>	find(DocumentQuery query, Class<T> domainType, String containerName) Find items
<T> reactor.core.publisher.Flux<T>	findAll(Class<T> domainType) Find all items in a given container
<T> reactor.core.publisher.Flux<T>	findAll(com.azure.data.cosmos.PartitionKey partitionKey, Class<T> domainType)
<T> reactor.core.publisher.Flux<T>	findAll(String containerName, Class<T> domainType) Find all items in a given container
<T> reactor.core.publisher.Mono<T>	findById(Object id, Class<T> domainType) Find by id
<T> reactor.core.publisher.Mono<T>	findById(Object id, Class<T> domainType, com.azure.data.cosmos.PartitionKey partitionKey) Find by id
<T> reactor.core.publisher.Mono<T>	findById(String containerName, Object id, Class<T> domainType) Find by id
private reactor.core.publisher.Flux<com.azure.data.cosmos.CosmosItemProperties>	findItems(DocumentQuery query, Class<?> domainType, String containerName)
String	getContainerName(Class<?> domainType)
MappingCosmosConverter	getConverter()
private CosmosEntityInformation<?,?>	getCosmosEntityInformation(Class<?> domainType)
private reactor.core.publisher.Mono<Long>	getCountValue(DocumentQuery query, boolean isCrossPartitionQuery, String containerName)
private List<String>	getPartitionKeyNames(Class<?> domainType)
<T> reactor.core.publisher.Mono<T>	insert(String containerName, Object objectToSave, com.azure.data.cosmos.PartitionKey partitionKey) Insert
<T> reactor.core.publisher.Mono<T>	insert(T objectToSave) Insert
<T> reactor.core.publisher.Mono<T>	insert(T objectToSave, com.azure.data.cosmos.PartitionKey partitionKey) Insert
void	setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
private <T> T	toDomainObject(Class<T> domainType, com.azure.data.cosmos.CosmosItemProperties cosmosItemProperties)
<T> reactor.core.publisher.Mono<T>	upsert(String containerName, T object, com.azure.data.cosmos.PartitionKey partitionKey) Upsert
<T> reactor.core.publisher.Mono<T>	upsert(T object, com.azure.data.cosmos.PartitionKey partitionKey) Upsert

Methods inherited from class java.lang.Object

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

Field Detail

COUNT_VALUE_KEY

private static final String COUNT_VALUE_KEY

See Also:

Constant Field Values

mappingCosmosConverter

private final MappingCosmosConverter mappingCosmosConverter

databaseName

private final String databaseName

cosmosClient

private final com.azure.data.cosmos.CosmosClient cosmosClient

responseDiagnosticsProcessor

private final ResponseDiagnosticsProcessor responseDiagnosticsProcessor

isPopulateQueryMetrics

private final boolean isPopulateQueryMetrics

entityInfoCreator

private Function<Class<?>,CosmosEntityInformation<?,?>> entityInfoCreator

containerNameCache

private final List<String> containerNameCache

Constructor Detail

ReactiveCosmosTemplate

public ReactiveCosmosTemplate(CosmosDbFactory cosmosDbFactory,
                              MappingCosmosConverter mappingCosmosConverter,
                              String dbName)

Constructor

Parameters:

cosmosDbFactory - the cosmosdbfactory

mappingCosmosConverter - the mappingCosmosConverter

dbName - database name

Method Detail

setApplicationContext

public void setApplicationContext(@NonNull
                                  org.springframework.context.ApplicationContext applicationContext)
                           throws org.springframework.beans.BeansException

Specified by:

setApplicationContext in interface org.springframework.context.ApplicationContextAware

Parameters:

applicationContext - the application context

Throws:

org.springframework.beans.BeansException - the bean exception

createCollectionIfNotExists

public reactor.core.publisher.Mono<com.azure.data.cosmos.CosmosContainerResponse> createCollectionIfNotExists(CosmosEntityInformation information)

Creates a container if it doesn't already exist

Specified by:

createCollectionIfNotExists in interface ReactiveCosmosOperations

Parameters:

information - the CosmosEntityInformation

Returns:

Mono containing CosmosContainerResponse

createContainerIfNotExists

public reactor.core.publisher.Mono<com.azure.data.cosmos.CosmosContainerResponse> createContainerIfNotExists(CosmosEntityInformation information)

Creates a container if it doesn't already exist

Specified by:

createContainerIfNotExists in interface ReactiveCosmosOperations

Parameters:

information - the CosmosEntityInformation

Returns:

Mono containing CosmosContainerResponse

findAll

public <T> reactor.core.publisher.Flux<T> findAll(String containerName,
                                                  Class<T> domainType)

Find all items in a given container

Specified by:

findAll in interface ReactiveCosmosOperations

Parameters:

containerName - the containerName

domainType - the domainType

Returns:

Flux with all the found items or error

findAll

public <T> reactor.core.publisher.Flux<T> findAll(Class<T> domainType)

Find all items in a given container

Specified by:

findAll in interface ReactiveCosmosOperations

Parameters:

domainType - the domainType

Returns:

Flux with all the found items or error

findAll

public <T> reactor.core.publisher.Flux<T> findAll(com.azure.data.cosmos.PartitionKey partitionKey,
                                                  Class<T> domainType)

Specified by:

findAll in interface ReactiveCosmosOperations

findById

public <T> reactor.core.publisher.Mono<T> findById(Object id,
                                                   Class<T> domainType)

Find by id

Specified by:

findById in interface ReactiveCosmosOperations

Parameters:

id - the id

domainType - the domainType

Returns:

Mono with the item or error

findById

public <T> reactor.core.publisher.Mono<T> findById(String containerName,
                                                   Object id,
                                                   Class<T> domainType)

Find by id

Specified by:

findById in interface ReactiveCosmosOperations

Parameters:

containerName - the containername

id - the id

domainType - the entity class

Returns:

Mono with the item or error

findById

public <T> reactor.core.publisher.Mono<T> findById(Object id,
                                                   Class<T> domainType,
                                                   com.azure.data.cosmos.PartitionKey partitionKey)

Find by id

Specified by:

findById in interface ReactiveCosmosOperations

Parameters:

id - the id

domainType - the entity class

partitionKey - partition Key

Returns:

Mono with the item or error

insert

public <T> reactor.core.publisher.Mono<T> insert(T objectToSave,
                                                 com.azure.data.cosmos.PartitionKey partitionKey)

Insert

Specified by:

insert in interface ReactiveCosmosOperations

Parameters:

objectToSave - the object to save

partitionKey - the partition key

Returns:

Mono with the item or error

insert

public <T> reactor.core.publisher.Mono<T> insert(T objectToSave)

Insert

Parameters:

objectToSave - the object to save

Returns:

Mono with the item or error

insert

public <T> reactor.core.publisher.Mono<T> insert(String containerName,
                                                 Object objectToSave,
                                                 com.azure.data.cosmos.PartitionKey partitionKey)

Insert

Specified by:

insert in interface ReactiveCosmosOperations

Parameters:

containerName - the container name

objectToSave - the object to save

partitionKey - the partition key

Returns:

Mono with the item or error

upsert

public <T> reactor.core.publisher.Mono<T> upsert(T object,
                                                 com.azure.data.cosmos.PartitionKey partitionKey)

Upsert

Specified by:

upsert in interface ReactiveCosmosOperations

Parameters:

object - the object to upsert

partitionKey - the partition key

Returns:

Mono with the item or error

upsert

public <T> reactor.core.publisher.Mono<T> upsert(String containerName,
                                                 T object,
                                                 com.azure.data.cosmos.PartitionKey partitionKey)

Upsert

Specified by:

upsert in interface ReactiveCosmosOperations

Parameters:

containerName - the container name

object - the object to save

partitionKey - the partition key

Returns:

Mono with the item or error

deleteById

public reactor.core.publisher.Mono<Void> deleteById(String containerName,
                                                    Object id,
                                                    com.azure.data.cosmos.PartitionKey partitionKey)

Delete an item by id

Specified by:

deleteById in interface ReactiveCosmosOperations

Parameters:

containerName - the container name

id - the id

partitionKey - the partition key

Returns:

void Mono

deleteAll

public reactor.core.publisher.Mono<Void> deleteAll(String containerName,
                                                   String partitionKeyName)

Delete all items in a container

Specified by:

deleteAll in interface ReactiveCosmosOperations

Parameters:

containerName - the container name

partitionKeyName - the partition key path

Returns:

void Mono

delete

public <T> reactor.core.publisher.Flux<T> delete(DocumentQuery query,
                                                 Class<T> domainType,
                                                 String containerName)

Delete items matching query

Specified by:

delete in interface ReactiveCosmosOperations

Parameters:

query - the document query

domainType - the entity class

containerName - the container name

Returns:

Mono

find

public <T> reactor.core.publisher.Flux<T> find(DocumentQuery query,
                                               Class<T> domainType,
                                               String containerName)

Find items

Specified by:

find in interface ReactiveCosmosOperations

Parameters:

query - the document query

domainType - the entity class

containerName - the container name

Returns:

Flux with found items or error

exists

public reactor.core.publisher.Mono<Boolean> exists(DocumentQuery query,
                                                   Class<?> domainType,
                                                   String containerName)

Exists

Specified by:

exists in interface ReactiveCosmosOperations

Parameters:

query - the document query

domainType - the entity class

containerName - the container name

Returns:

Mono with a boolean or error

existsById

public reactor.core.publisher.Mono<Boolean> existsById(Object id,
                                                       Class<?> domainType,
                                                       String containerName)

Exists

Specified by:

existsById in interface ReactiveCosmosOperations

Parameters:

id - the id

domainType - the entity class

containerName - the containercontainer nam,e

Returns:

Mono with a boolean or error

count

public reactor.core.publisher.Mono<Long> count(String containerName)

Count

Specified by:

count in interface ReactiveCosmosOperations

Parameters:

containerName - the container name

Returns:

Mono with the count or error

count

public reactor.core.publisher.Mono<Long> count(DocumentQuery query,
                                               String containerName)

Count

Specified by:

count in interface ReactiveCosmosOperations

Parameters:

query - the document query

containerName - the container name

Returns:

Mono with count or error

getConverter

public MappingCosmosConverter getConverter()

Specified by:

getConverter in interface ReactiveCosmosOperations

count

public reactor.core.publisher.Mono<Long> count(DocumentQuery query,
                                               boolean isCrossPartitionQuery,
                                               String containerName)

getCountValue

private reactor.core.publisher.Mono<Long> getCountValue(DocumentQuery query,
                                                        boolean isCrossPartitionQuery,
                                                        String containerName)

executeQuery

private reactor.core.publisher.Flux<com.azure.data.cosmos.FeedResponse<com.azure.data.cosmos.CosmosItemProperties>> executeQuery(com.azure.data.cosmos.SqlQuerySpec sqlQuerySpec,
                                                                                                                                 String containerName,
                                                                                                                                 com.azure.data.cosmos.FeedOptions options)

deleteContainer

public void deleteContainer(@NonNull
                            String containerName)

Delete container with container name

Specified by:

deleteContainer in interface ReactiveCosmosOperations

Parameters:

containerName - the container name

getContainerName

public String getContainerName(Class<?> domainType)

Specified by:

getContainerName in interface ReactiveCosmosOperations

Parameters:

domainType - the domain class

Returns:

the container name

findItems

private reactor.core.publisher.Flux<com.azure.data.cosmos.CosmosItemProperties> findItems(@NonNull
                                                                                          DocumentQuery query,
                                                                                          @NonNull
                                                                                          Class<?> domainType,
                                                                                          @NonNull
                                                                                          String containerName)

assertValidId

private void assertValidId(Object id)

getPartitionKeyNames

private List<String> getPartitionKeyNames(Class<?> domainType)

deleteItem

private reactor.core.publisher.Mono<com.azure.data.cosmos.CosmosItemProperties> deleteItem(@NonNull
                                                                                           com.azure.data.cosmos.CosmosItemProperties cosmosItemProperties,
                                                                                           @NonNull
                                                                                           List<String> partitionKeyNames,
                                                                                           String containerName,
                                                                                           @NonNull
                                                                                           Class<?> domainType)

toDomainObject

private <T> T toDomainObject(@NonNull
                             Class<T> domainType,
                             com.azure.data.cosmos.CosmosItemProperties cosmosItemProperties)

applyVersioning

private void applyVersioning(Class<?> domainType,
                             com.azure.data.cosmos.CosmosItemProperties cosmosItemProperties,
                             com.azure.data.cosmos.CosmosItemRequestOptions options)

getCosmosEntityInformation

private CosmosEntityInformation<?,?> getCosmosEntityInformation(Class<?> domainType)