org.springframework.transaction.reactive

Interface TransactionalOperator

public interface TransactionalOperator

Operator class that simplifies programmatic transaction demarcation and transaction exception handling.

The central method is transactional(reactor.core.publisher.Flux<T>), supporting transactional wrapping of functional sequences code that. This operator handles the transaction lifecycle and possible exceptions such that neither the ReactiveTransactionCallback implementation nor the calling code needs to explicitly handle transactions.

Typical usage: Allows for writing low-level data access objects that use resources such as database connections but are not transaction-aware themselves. Instead, they can implicitly participate in transactions handled by higher-level application services utilizing this class, making calls to the low-level services via an inner-class callback object.

Transactional Publishers should avoid Subscription cancellation. Cancelling initiates asynchronous transaction cleanup that does not allow for synchronization on completion.

Since:

5.2

Author:

Mark Paluch, Juergen Hoeller

See Also:

execute(org.springframework.transaction.reactive.TransactionCallback<T>), ReactiveTransactionManager

Method Summary

Modifier and Type	Method and Description
static TransactionalOperator	create(ReactiveTransactionManager transactionManager) Create a new TransactionalOperator using ReactiveTransactionManager, using a default transaction.
static TransactionalOperator	create(ReactiveTransactionManager transactionManager, TransactionDefinition transactionDefinition) Create a new TransactionalOperator using ReactiveTransactionManager and TransactionDefinition.
<T> reactor.core.publisher.Flux<T>	execute(TransactionCallback<T> action) Execute the action specified by the given callback object within a transaction.
default <T> reactor.core.publisher.Flux<T>	transactional(reactor.core.publisher.Flux<T> flux) Wrap the functional sequence specified by the given Flux within a transaction.
<T> reactor.core.publisher.Mono<T>	transactional(reactor.core.publisher.Mono<T> mono) Wrap the functional sequence specified by the given Mono within a transaction.

Method Detail

transactional

default <T> reactor.core.publisher.Flux<T> transactional(reactor.core.publisher.Flux<T> flux)

Wrap the functional sequence specified by the given Flux within a transaction.

Parameters:

flux - the Flux that should be executed within the transaction

Returns:

a result publisher returned by the callback, or null if none

Throws:

TransactionException - in case of initialization, rollback, or system errors

RuntimeException - if thrown by the TransactionCallback

transactional

<T> reactor.core.publisher.Mono<T> transactional(reactor.core.publisher.Mono<T> mono)

Wrap the functional sequence specified by the given Mono within a transaction.

Parameters:

mono - the Mono that should be executed within the transaction

Returns:

a result publisher returned by the callback

Throws:

TransactionException - in case of initialization, rollback, or system errors

RuntimeException - if thrown by the TransactionCallback

execute

<T> reactor.core.publisher.Flux<T> execute(TransactionCallback<T> action)
                                    throws TransactionException

Execute the action specified by the given callback object within a transaction.

Allows for returning a result object created within the transaction, that is, a domain object or a collection of domain objects. A RuntimeException thrown by the callback is treated as a fatal exception that enforces a rollback. Such an exception gets propagated to the caller of the template.

Parameters:

action - the callback object that specifies the transactional action

Returns:

a result object returned by the callback

Throws:

TransactionException - in case of initialization, rollback, or system errors

RuntimeException - if thrown by the TransactionCallback

create

static TransactionalOperator create(ReactiveTransactionManager transactionManager)

Create a new TransactionalOperator using ReactiveTransactionManager, using a default transaction.

Parameters:

transactionManager - the transaction management strategy to be used

Returns:

the transactional operator

create

static TransactionalOperator create(ReactiveTransactionManager transactionManager,
                                    TransactionDefinition transactionDefinition)

Create a new TransactionalOperator using ReactiveTransactionManager and TransactionDefinition.

Parameters:

transactionManager - the transaction management strategy to be used

transactionDefinition - the transaction definition to apply

Returns:

the transactional operator