org.springframework.data.neo4j.core

Class ReactiveNeo4jTemplate

java.lang.Object

org.springframework.data.neo4j.core.ReactiveNeo4jTemplate

All Implemented Interfaces:

Aware, BeanClassLoaderAware, BeanFactoryAware, ReactiveFluentFindOperation, ReactiveFluentNeo4jOperations, ReactiveFluentSaveOperation, ReactiveNeo4jOperations

@API(status=STABLE,
     since="6.0")
public final class ReactiveNeo4jTemplate
extends Object
implements ReactiveNeo4jOperations, ReactiveFluentNeo4jOperations, BeanClassLoaderAware, BeanFactoryAware

Since:

6.0

Author:

Michael J. Simons, Gerrit Meier, Philipp Tölle

Nested Class Summary

Nested classes/interfaces inherited from interface org.springframework.data.neo4j.core.ReactiveNeo4jOperations

ReactiveNeo4jOperations.ExecutableQuery<T>

Nested classes/interfaces inherited from interface org.springframework.data.neo4j.core.ReactiveFluentFindOperation

ReactiveFluentFindOperation.ExecutableFind<T>, ReactiveFluentFindOperation.FindWithProjection<T>, ReactiveFluentFindOperation.FindWithQuery<T>, ReactiveFluentFindOperation.TerminatingFind<T>, ReactiveFluentFindOperation.TerminatingFindWithoutQuery<T>

Nested classes/interfaces inherited from interface org.springframework.data.neo4j.core.ReactiveFluentSaveOperation

ReactiveFluentSaveOperation.ExecutableSave<DT>

Constructor Summary

Constructors

Constructor and Description
ReactiveNeo4jTemplate(ReactiveNeo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext)
ReactiveNeo4jTemplate(ReactiveNeo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext, ReactiveDatabaseSelectionProvider databaseSelectionProvider) Deprecated.

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Mono<Long>	count(Class<?> domainType) Counts the number of entities of a given type.
reactor.core.publisher.Mono<Long>	count(org.neo4j.cypherdsl.core.Statement statement) Counts the number of entities of a given type.
reactor.core.publisher.Mono<Long>	count(org.neo4j.cypherdsl.core.Statement statement, Map<String,Object> parameters) Counts the number of entities of a given type.
reactor.core.publisher.Mono<Long>	count(String cypherQuery) Counts the number of entities of a given type.
reactor.core.publisher.Mono<Long>	count(String cypherQuery, Map<String,Object> parameters) Counts the number of entities of a given type.
reactor.core.publisher.Mono<Void>	deleteAll(Class<?> domainType) Delete all entities of a given type.
<T> reactor.core.publisher.Mono<Void>	deleteAllById(Iterable<?> ids, Class<T> domainType) Deletes all entities with one of the given ids, including all entities related to that entity.
<T> reactor.core.publisher.Mono<Void>	deleteById(Object id, Class<T> domainType) Deletes a single entity including all entities related to that entity.
<T> reactor.core.publisher.Mono<Void>	deleteByIdWithVersion(Object id, Class<T> domainType, Neo4jPersistentProperty versionProperty, Object versionValue)
<T> ReactiveFluentFindOperation.ExecutableFind<T>	find(Class<T> domainType) Start creating a find operation for the given domainType.
<T> reactor.core.publisher.Flux<T>	findAll(Class<T> domainType) Load all entities of a given type.
<T> reactor.core.publisher.Flux<T>	findAll(org.neo4j.cypherdsl.core.Statement statement, Class<T> domainType) Load all entities of a given type by executing given statement.
<T> reactor.core.publisher.Flux<T>	findAll(org.neo4j.cypherdsl.core.Statement statement, Map<String,Object> parameters, Class<T> domainType) Load all entities of a given type by executing given statement with parameters.
<T> reactor.core.publisher.Flux<T>	findAll(String cypherQuery, Class<T> domainType) Load all entities of a given type by executing given statement.
<T> reactor.core.publisher.Flux<T>	findAll(String cypherQuery, Map<String,Object> parameters, Class<T> domainType) Load all entities of a given type by executing given statement with parameters.
<T> reactor.core.publisher.Flux<T>	findAllById(Iterable<?> ids, Class<T> domainType) Load all entities of a given type that are identified by the given ids.
<T> reactor.core.publisher.Mono<T>	findById(Object id, Class<T> domainType) Load an entity from the database.
<T> reactor.core.publisher.Mono<T>	findOne(org.neo4j.cypherdsl.core.Statement statement, Map<String,Object> parameters, Class<T> domainType) Load one entity of a given type by executing given statement with parameters.
<T> reactor.core.publisher.Mono<T>	findOne(String cypherQuery, Map<String,Object> parameters, Class<T> domainType) Load one entity of a given type by executing given statement with parameters.
<T> ReactiveFluentSaveOperation.ExecutableSave<T>	save(Class<T> domainType) Start creating a save operation for the given domainType.
<T> reactor.core.publisher.Mono<T>	save(T instance) Saves an instance of an entity, including all the related entities of the entity.
<T> reactor.core.publisher.Flux<T>	saveAll(Iterable<T> instances) Saves several instances of an entity, including all the related entities of the entity.
<T,R> reactor.core.publisher.Flux<R>	saveAllAs(Iterable<T> instances, Class<R> resultType) Saves several instances of an entity, including the properties and relationship defined by the project resultType.
<T,R> reactor.core.publisher.Mono<R>	saveAs(T instance, Class<R> resultType) Saves an instance of an entity, including the properties and relationship defined by the projected resultType.
void	setBeanClassLoader(ClassLoader classLoader)
void	setBeanFactory(BeanFactory beanFactory)
<T> reactor.core.publisher.Mono<ReactiveNeo4jOperations.ExecutableQuery<T>>	toExecutableQuery(Class<T> domainType, QueryFragmentsAndParameters queryFragmentsAndParameters) Create an executable query based on query fragment.
<T> reactor.core.publisher.Mono<ReactiveNeo4jOperations.ExecutableQuery<T>>	toExecutableQuery(PreparedQuery<T> preparedQuery) Takes a prepared query, containing all the information about the cypher template to be used, needed parameters and an optional mapping function, and turns it into an executable query.

Methods inherited from class java.lang.Object

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

Constructor Detail

ReactiveNeo4jTemplate

@Deprecated
public ReactiveNeo4jTemplate(ReactiveNeo4jClient neo4jClient,
                                         Neo4jMappingContext neo4jMappingContext,
                                         ReactiveDatabaseSelectionProvider databaseSelectionProvider)

Deprecated.

ReactiveNeo4jTemplate

public ReactiveNeo4jTemplate(ReactiveNeo4jClient neo4jClient,
                             Neo4jMappingContext neo4jMappingContext)

Method Detail

count

public reactor.core.publisher.Mono<Long> count(Class<?> domainType)

Description copied from interface: ReactiveNeo4jOperations

Counts the number of entities of a given type.

Specified by:

count in interface ReactiveNeo4jOperations

Parameters:

domainType - the type of the entities to be counted.

Returns:

the number of instances stored in the database. Guaranteed to be not null.

count

public reactor.core.publisher.Mono<Long> count(org.neo4j.cypherdsl.core.Statement statement)

Description copied from interface: ReactiveNeo4jOperations

Counts the number of entities of a given type.

Specified by:

count in interface ReactiveNeo4jOperations

Parameters:

statement - the Cypher Statement that returns the count.

Returns:

the number of instances stored in the database. Guaranteed to be not null.

count

public reactor.core.publisher.Mono<Long> count(org.neo4j.cypherdsl.core.Statement statement,
                                               Map<String,Object> parameters)

Description copied from interface: ReactiveNeo4jOperations

Counts the number of entities of a given type.

Specified by:

count in interface ReactiveNeo4jOperations

Parameters:

statement - the Cypher Statement that returns the count.

parameters - Map of parameters. Must not be null.

Returns:

the number of instances stored in the database. Guaranteed to be not null.

count

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

Description copied from interface: ReactiveNeo4jOperations

Counts the number of entities of a given type.

Specified by:

count in interface ReactiveNeo4jOperations

Parameters:

cypherQuery - the Cypher query that returns the count.

Returns:

the number of instances stored in the database. Guaranteed to be not null.

count

public reactor.core.publisher.Mono<Long> count(String cypherQuery,
                                               Map<String,Object> parameters)

Description copied from interface: ReactiveNeo4jOperations

Counts the number of entities of a given type.

Specified by:

count in interface ReactiveNeo4jOperations

Parameters:

cypherQuery - the Cypher query that returns the count.

parameters - Map of parameters. Must not be null.

Returns:

the number of instances stored in the database. Guaranteed to be not null.

findAll

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

Description copied from interface: ReactiveNeo4jOperations

Load all entities of a given type.

Specified by:

findAll in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

findAll

public <T> reactor.core.publisher.Flux<T> findAll(org.neo4j.cypherdsl.core.Statement statement,
                                                  Class<T> domainType)

Description copied from interface: ReactiveNeo4jOperations

Load all entities of a given type by executing given statement.

Specified by:

findAll in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

statement - Cypher Statement. Must not be null.

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

findAll

public <T> reactor.core.publisher.Flux<T> findAll(org.neo4j.cypherdsl.core.Statement statement,
                                                  Map<String,Object> parameters,
                                                  Class<T> domainType)

Description copied from interface: ReactiveNeo4jOperations

Load all entities of a given type by executing given statement with parameters.

Specified by:

findAll in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

statement - Cypher Statement. Must not be null.

parameters - Map of parameters. Must not be null.

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

findOne

public <T> reactor.core.publisher.Mono<T> findOne(org.neo4j.cypherdsl.core.Statement statement,
                                                  Map<String,Object> parameters,
                                                  Class<T> domainType)

Description copied from interface: ReactiveNeo4jOperations

Load one entity of a given type by executing given statement with parameters.

Specified by:

findOne in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

statement - Cypher Statement. Must not be null.

parameters - Map of parameters. Must not be null.

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

findAll

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

Description copied from interface: ReactiveNeo4jOperations

Load all entities of a given type by executing given statement.

Specified by:

findAll in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

cypherQuery - Cypher query string. Must not be null.

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

findAll

public <T> reactor.core.publisher.Flux<T> findAll(String cypherQuery,
                                                  Map<String,Object> parameters,
                                                  Class<T> domainType)

Description copied from interface: ReactiveNeo4jOperations

Load all entities of a given type by executing given statement with parameters.

Specified by:

findAll in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

cypherQuery - Cypher query string. Must not be null.

parameters - Map of parameters. Must not be null.

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

findOne

public <T> reactor.core.publisher.Mono<T> findOne(String cypherQuery,
                                                  Map<String,Object> parameters,
                                                  Class<T> domainType)

Description copied from interface: ReactiveNeo4jOperations

Load one entity of a given type by executing given statement with parameters.

Specified by:

findOne in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

cypherQuery - Cypher query string. Must not be null.

parameters - Map of parameters. Must not be null.

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

find

public <T> ReactiveFluentFindOperation.ExecutableFind<T> find(Class<T> domainType)

Description copied from interface: ReactiveFluentFindOperation

Start creating a find operation for the given domainType.

Specified by:

find in interface ReactiveFluentFindOperation

Parameters:

domainType - must not be null.

Returns:

new instance of ReactiveFluentFindOperation.ExecutableFind.

findById

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

Description copied from interface: ReactiveNeo4jOperations

Load an entity from the database.

Specified by:

findById in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entity.

Parameters:

id - the id of the entity to load. Must not be null.

domainType - the type of the entity. Must not be null.

Returns:

the loaded entity. Might return an empty optional.

findAllById

public <T> reactor.core.publisher.Flux<T> findAllById(Iterable<?> ids,
                                                      Class<T> domainType)

Description copied from interface: ReactiveNeo4jOperations

Load all entities of a given type that are identified by the given ids.

Specified by:

findAllById in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entities. Must not be null.

Parameters:

ids - of the entities identifying the entities to load. Must not be null.

domainType - the type of the entities. Must not be null.

Returns:

Guaranteed to be not null.

toExecutableQuery

public <T> reactor.core.publisher.Mono<ReactiveNeo4jOperations.ExecutableQuery<T>> toExecutableQuery(Class<T> domainType,
                                                                                                     QueryFragmentsAndParameters queryFragmentsAndParameters)

Description copied from interface: ReactiveNeo4jOperations

Create an executable query based on query fragment.

Specified by:

toExecutableQuery in interface ReactiveNeo4jOperations

Type Parameters:

T - The type of the objects returned by this query.

Parameters:

domainType - domain class the executable query should return

queryFragmentsAndParameters - fragments and parameters to construct the query from

Returns:

An executable query

save

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

Description copied from interface: ReactiveNeo4jOperations

Saves an instance of an entity, including all the related entities of the entity.

Specified by:

save in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entity.

Parameters:

instance - the entity to be saved. Must not be null.

Returns:

the saved instance.

saveAs

public <T,R> reactor.core.publisher.Mono<R> saveAs(T instance,
                                                   Class<R> resultType)

Description copied from interface: ReactiveNeo4jOperations

Saves an instance of an entity, including the properties and relationship defined by the projected resultType.

Specified by:

saveAs in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entity.

R - the type of the projection to be used during save.

Parameters:

instance - the entity to be saved. Must not be null.

Returns:

the saved, projected instance.

saveAll

public <T> reactor.core.publisher.Flux<T> saveAll(Iterable<T> instances)

Description copied from interface: ReactiveNeo4jOperations

Saves several instances of an entity, including all the related entities of the entity.

Specified by:

saveAll in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entity.

Parameters:

instances - the instances to be saved. Must not be null.

Returns:

the saved instances.

saveAllAs

public <T,R> reactor.core.publisher.Flux<R> saveAllAs(Iterable<T> instances,
                                                      Class<R> resultType)

Description copied from interface: ReactiveNeo4jOperations

Saves several instances of an entity, including the properties and relationship defined by the project resultType.

Specified by:

saveAllAs in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entity.

R - the type of the projection to be used during save.

Parameters:

instances - the instances to be saved. Must not be null.

Returns:

the saved, projected instance.

deleteAllById

public <T> reactor.core.publisher.Mono<Void> deleteAllById(Iterable<?> ids,
                                                           Class<T> domainType)

Description copied from interface: ReactiveNeo4jOperations

Deletes all entities with one of the given ids, including all entities related to that entity.

Specified by:

deleteAllById in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entity.

Parameters:

ids - the ids of the entities to be deleted. Must not be null.

domainType - the type of the entity

deleteById

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

Description copied from interface: ReactiveNeo4jOperations

Deletes a single entity including all entities related to that entity.

Specified by:

deleteById in interface ReactiveNeo4jOperations

Type Parameters:

T - the type of the entity.

Parameters:

id - the id of the entity to be deleted. Must not be null.

domainType - the type of the entity

deleteByIdWithVersion

public <T> reactor.core.publisher.Mono<Void> deleteByIdWithVersion(Object id,
                                                                   Class<T> domainType,
                                                                   Neo4jPersistentProperty versionProperty,
                                                                   Object versionValue)

Specified by:

deleteByIdWithVersion in interface ReactiveNeo4jOperations

deleteAll

public reactor.core.publisher.Mono<Void> deleteAll(Class<?> domainType)

Description copied from interface: ReactiveNeo4jOperations

Delete all entities of a given type.

Specified by:

deleteAll in interface ReactiveNeo4jOperations

Parameters:

domainType - type of the entities to be deleted. Must not be null.

toExecutableQuery

public <T> reactor.core.publisher.Mono<ReactiveNeo4jOperations.ExecutableQuery<T>> toExecutableQuery(PreparedQuery<T> preparedQuery)

Description copied from interface: ReactiveNeo4jOperations

Takes a prepared query, containing all the information about the cypher template to be used, needed parameters and an optional mapping function, and turns it into an executable query.

Specified by:

toExecutableQuery in interface ReactiveNeo4jOperations

Type Parameters:

T - The type of the objects returned by this query.

Parameters:

preparedQuery - prepared query that should get converted to an executable query

Returns:

An executable query

setBeanFactory

public void setBeanFactory(BeanFactory beanFactory)
                    throws BeansException

Specified by:

setBeanFactory in interface BeanFactoryAware

Throws:

BeansException

setBeanClassLoader

public void setBeanClassLoader(ClassLoader classLoader)

Specified by:

setBeanClassLoader in interface BeanClassLoaderAware

save

public <T> ReactiveFluentSaveOperation.ExecutableSave<T> save(Class<T> domainType)

Description copied from interface: ReactiveFluentSaveOperation

Start creating a save operation for the given domainType.

Specified by:

save in interface ReactiveFluentSaveOperation

Parameters:

domainType - must not be null.

Returns:

new instance of ReactiveFluentSaveOperation.ExecutableSave.