org.springframework.data.r2dbc.core

Class R2dbcEntityTemplate

java.lang.Object

org.springframework.data.r2dbc.core.R2dbcEntityTemplate

All Implemented Interfaces:

Aware, BeanFactoryAware, FluentR2dbcOperations, R2dbcEntityOperations, ReactiveDeleteOperation, ReactiveInsertOperation, ReactiveSelectOperation, ReactiveUpdateOperation

public class R2dbcEntityTemplate
extends Object
implements R2dbcEntityOperations, BeanFactoryAware

Implementation of R2dbcEntityOperations. It simplifies the use of Reactive R2DBC usage through entities and helps to avoid common errors. This class uses DatabaseClient to execute SQL queries or updates, initiating iteration over Result.

Can be used within a service implementation via direct instantiation with a DatabaseClient reference, or get prepared in an application context and given to services as bean reference.

Since:

1.1

Author:

Mark Paluch, Bogdan Ilchyshyn

Nested Class Summary

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveSelectOperation

ReactiveSelectOperation.ReactiveSelect<T>, ReactiveSelectOperation.SelectWithProjection<T>, ReactiveSelectOperation.SelectWithQuery<T>, ReactiveSelectOperation.SelectWithTable<T>, ReactiveSelectOperation.TerminatingSelect<T>

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveInsertOperation

ReactiveInsertOperation.InsertWithTable<T>, ReactiveInsertOperation.ReactiveInsert<T>, ReactiveInsertOperation.TerminatingInsert<T>

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveUpdateOperation

ReactiveUpdateOperation.ReactiveUpdate, ReactiveUpdateOperation.TerminatingUpdate, ReactiveUpdateOperation.UpdateWithQuery, ReactiveUpdateOperation.UpdateWithTable

Nested classes/interfaces inherited from interface org.springframework.data.r2dbc.core.ReactiveDeleteOperation

ReactiveDeleteOperation.DeleteWithQuery, ReactiveDeleteOperation.DeleteWithTable, ReactiveDeleteOperation.ReactiveDelete, ReactiveDeleteOperation.TerminatingDelete

Constructor Summary

Constructors

Constructor and Description
R2dbcEntityTemplate(DatabaseClient databaseClient) Create a new R2dbcEntityTemplate given DatabaseClient.
R2dbcEntityTemplate(DatabaseClient databaseClient, ReactiveDataAccessStrategy strategy) Create a new R2dbcEntityTemplate given DatabaseClient and ReactiveDataAccessStrategy.

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Mono<Long>	count(org.springframework.data.relational.core.query.Query query, Class<?> entityClass) Returns the number of rows for the given entity class applying Query.
ReactiveDeleteOperation.ReactiveDelete	delete(Class<?> domainType) Begin creating a DELETE operation for the given domainType.
reactor.core.publisher.Mono<Integer>	delete(org.springframework.data.relational.core.query.Query query, Class<?> entityClass) Remove entities (rows)/columns from the table by Query.
<T> reactor.core.publisher.Mono<T>	delete(T entity) Delete the given entity and emit the entity if the delete was applied.
reactor.core.publisher.Mono<Boolean>	exists(org.springframework.data.relational.core.query.Query query, Class<?> entityClass) Determine whether the result for entityClass Query yields at least one row.
DatabaseClient	getDatabaseClient() Expose the underlying DatabaseClient to allow SQL operations.
<T> ReactiveInsertOperation.ReactiveInsert<T>	insert(Class<T> domainType) Begin creating an INSERT operation for given domainType.
<T> reactor.core.publisher.Mono<T>	insert(T entity) Insert the given entity and emit the entity if the insert was applied.
<T> ReactiveSelectOperation.ReactiveSelect<T>	select(Class<T> domainType) Begin creating a SELECT operation for the given domainType.
<T> reactor.core.publisher.Flux<T>	select(org.springframework.data.relational.core.query.Query query, Class<T> entityClass) Execute a SELECT query and convert the resulting items to a stream of entities.
<T> reactor.core.publisher.Mono<T>	selectOne(org.springframework.data.relational.core.query.Query query, Class<T> entityClass) Execute a SELECT query and convert the resulting item to an entity.
void	setBeanFactory(BeanFactory beanFactory)
ReactiveUpdateOperation.ReactiveUpdate	update(Class<?> domainType) Begin creating an UPDATE operation for the given domainType.
reactor.core.publisher.Mono<Integer>	update(org.springframework.data.relational.core.query.Query query, org.springframework.data.relational.core.query.Update update, Class<?> entityClass) Update the queried entities and return true if the update was applied.
<T> reactor.core.publisher.Mono<T>	update(T entity) Update the given entity and emit the entity if the update was applied.

Methods inherited from class java.lang.Object

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

Constructor Detail

R2dbcEntityTemplate

public R2dbcEntityTemplate(DatabaseClient databaseClient)

Create a new R2dbcEntityTemplate given DatabaseClient.

Parameters:

databaseClient - must not be null.

R2dbcEntityTemplate

public R2dbcEntityTemplate(DatabaseClient databaseClient,
                           ReactiveDataAccessStrategy strategy)

Create a new R2dbcEntityTemplate given DatabaseClient and ReactiveDataAccessStrategy.

Parameters:

databaseClient - must not be null.

Method Detail

getDatabaseClient

public DatabaseClient getDatabaseClient()

Description copied from interface: R2dbcEntityOperations

Expose the underlying DatabaseClient to allow SQL operations.

Specified by:

getDatabaseClient in interface R2dbcEntityOperations

Returns:

the underlying DatabaseClient.

See Also:

DatabaseClient

setBeanFactory

public void setBeanFactory(BeanFactory beanFactory)
                    throws BeansException

Specified by:

setBeanFactory in interface BeanFactoryAware

Throws:

BeansException

select

public <T> ReactiveSelectOperation.ReactiveSelect<T> select(Class<T> domainType)

Description copied from interface: ReactiveSelectOperation

Begin creating a SELECT operation for the given domainType.

Specified by:

select in interface ReactiveSelectOperation

Type Parameters:

T - type of the application domain object.

Parameters:

domainType - type of the domain object to query; must not be null.

Returns:

new instance of ReactiveSelectOperation.ReactiveSelect.

See Also:

ReactiveSelectOperation.ReactiveSelect

insert

public <T> ReactiveInsertOperation.ReactiveInsert<T> insert(Class<T> domainType)

Description copied from interface: ReactiveInsertOperation

Begin creating an INSERT operation for given domainType.

Specified by:

insert in interface ReactiveInsertOperation

Type Parameters:

T - type of the application domain object.

Parameters:

domainType - type of the domain object to insert; must not be null.

Returns:

new instance of ReactiveInsertOperation.ReactiveInsert.

See Also:

ReactiveInsertOperation.ReactiveInsert

update

public ReactiveUpdateOperation.ReactiveUpdate update(Class<?> domainType)

Description copied from interface: ReactiveUpdateOperation

Begin creating an UPDATE operation for the given domainType.

Specified by:

update in interface ReactiveUpdateOperation

Parameters:

domainType - type of domain object to update; must not be null.

Returns:

new instance of ReactiveUpdateOperation.ReactiveUpdate.

See Also:

ReactiveUpdateOperation.ReactiveUpdate

delete

public ReactiveDeleteOperation.ReactiveDelete delete(Class<?> domainType)

Description copied from interface: ReactiveDeleteOperation

Begin creating a DELETE operation for the given domainType.

Specified by:

delete in interface ReactiveDeleteOperation

Parameters:

domainType - type of domain object to delete; must not be null.

Returns:

new instance of ReactiveDeleteOperation.ReactiveDelete.

See Also:

ReactiveDeleteOperation.ReactiveDelete

count

public reactor.core.publisher.Mono<Long> count(org.springframework.data.relational.core.query.Query query,
                                               Class<?> entityClass)
                                        throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Returns the number of rows for the given entity class applying Query. This overridden method allows users to further refine the selection Query using a Query predicate to determine how many entities of the given type match the Query.

Specified by:

count in interface R2dbcEntityOperations

Parameters:

query - user-defined count Query to execute; must not be null.

entityClass - type of the entity; must not be null.

Returns:

the number of existing entities.

Throws:

DataAccessException - if any problem occurs while executing the query.

exists

public reactor.core.publisher.Mono<Boolean> exists(org.springframework.data.relational.core.query.Query query,
                                                   Class<?> entityClass)
                                            throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Determine whether the result for entityClass Query yields at least one row.

Specified by:

exists in interface R2dbcEntityOperations

Parameters:

query - user-defined exists Query to execute; must not be null.

entityClass - type of the entity; must not be null.

Returns:

true if the object exists.

Throws:

DataAccessException - if any problem occurs while executing the query.

select

public <T> reactor.core.publisher.Flux<T> select(org.springframework.data.relational.core.query.Query query,
                                                 Class<T> entityClass)
                                          throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Execute a SELECT query and convert the resulting items to a stream of entities.

Specified by:

select in interface R2dbcEntityOperations

Parameters:

query - must not be null.

entityClass - The entity type must not be null.

Returns:

the result objects returned by the action.

Throws:

DataAccessException - if there is any problem issuing the execution.

selectOne

public <T> reactor.core.publisher.Mono<T> selectOne(org.springframework.data.relational.core.query.Query query,
                                                    Class<T> entityClass)
                                             throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Execute a SELECT query and convert the resulting item to an entity.

Specified by:

selectOne in interface R2dbcEntityOperations

Parameters:

query - must not be null.

entityClass - The entity type must not be null.

Returns:

the result object returned by the action or Mono.empty().

Throws:

DataAccessException - if there is any problem issuing the execution.

update

public reactor.core.publisher.Mono<Integer> update(org.springframework.data.relational.core.query.Query query,
                                                   org.springframework.data.relational.core.query.Update update,
                                                   Class<?> entityClass)
                                            throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Update the queried entities and return true if the update was applied.

Specified by:

update in interface R2dbcEntityOperations

Parameters:

query - must not be null.

update - must not be null.

entityClass - The entity type must not be null.

Returns:

the number of affected rows.

Throws:

DataAccessException - if there is any problem executing the query.

delete

public reactor.core.publisher.Mono<Integer> delete(org.springframework.data.relational.core.query.Query query,
                                                   Class<?> entityClass)
                                            throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Remove entities (rows)/columns from the table by Query.

Specified by:

delete in interface R2dbcEntityOperations

Parameters:

query - must not be null.

entityClass - The entity type must not be null.

Returns:

the number of affected rows.

Throws:

DataAccessException - if there is any problem issuing the execution.

insert

public <T> reactor.core.publisher.Mono<T> insert(T entity)
                                          throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Insert the given entity and emit the entity if the insert was applied.

Specified by:

insert in interface R2dbcEntityOperations

Parameters:

entity - The entity to insert, must not be null.

Returns:

the inserted entity.

Throws:

DataAccessException - if there is any problem issuing the execution.

update

public <T> reactor.core.publisher.Mono<T> update(T entity)
                                          throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Update the given entity and emit the entity if the update was applied.

Specified by:

update in interface R2dbcEntityOperations

Parameters:

entity - The entity to update, must not be null.

Returns:

the updated entity.

Throws:

DataAccessException - if there is any problem issuing the execution.

TransientDataAccessResourceException - if the update did not affect any rows.

delete

public <T> reactor.core.publisher.Mono<T> delete(T entity)
                                          throws DataAccessException

Description copied from interface: R2dbcEntityOperations

Delete the given entity and emit the entity if the delete was applied.

Specified by:

delete in interface R2dbcEntityOperations

Parameters:

entity - must not be null.

Returns:

the deleted entity.

Throws:

DataAccessException - if there is any problem issuing the execution.