com.couchbase.client.java.transactions

Class ReactiveTransactions

java.lang.Object

com.couchbase.client.java.transactions.ReactiveTransactions

public class ReactiveTransactions
extends Object

An asynchronous version of Transactions, allowing transactions to be created and run in an asynchronous manner.

The main method to run transactions is run(java.util.function.Function<com.couchbase.client.java.transactions.ReactiveTransactionAttemptContext, reactor.core.publisher.Mono<?>>, com.couchbase.client.java.transactions.config.TransactionOptions).

Constructor Summary

Constructors

Constructor and Description
ReactiveTransactions(com.couchbase.client.core.Core core, JsonSerializer serializer)

Method Summary

Modifier and Type	Method and Description
Mono<TransactionResult>	run(Function<ReactiveTransactionAttemptContext,Mono<?>> transactionLogic) Convenience overload that runs run(java.util.function.Function<com.couchbase.client.java.transactions.ReactiveTransactionAttemptContext, reactor.core.publisher.Mono<?>>, com.couchbase.client.java.transactions.config.TransactionOptions) with a default PerTransactionConfig.
Mono<TransactionResult>	run(Function<ReactiveTransactionAttemptContext,Mono<?>> transactionLogic, TransactionOptions options) Runs the supplied transactional logic until success or failure.

Methods inherited from class java.lang.Object

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

Constructor Detail

ReactiveTransactions

@Stability.Internal
public ReactiveTransactions(com.couchbase.client.core.Core core,
                                                JsonSerializer serializer)

Method Detail

run

public Mono<TransactionResult> run(Function<ReactiveTransactionAttemptContext,Mono<?>> transactionLogic,
                                   @Nullable
                                   TransactionOptions options)

Runs the supplied transactional logic until success or failure.

This is the asynchronous version of Transactions.run(java.util.function.Consumer<com.couchbase.client.java.transactions.TransactionAttemptContext>, com.couchbase.client.java.transactions.config.TransactionOptions), so to cover the differences:

• The transaction logic is supplied with a CoreTransactionAttemptContext, which contains asynchronous methods to allow it to read, mutate, insert and delete documents.
• The transaction logic should run these methods as a Reactor chain - as standard with reactive programming.
• The transaction logic should return a Mono<Void>. Any Flux or Mono can be converted to a Mono<Void> by calling .then() on it.
• This method returns a Mono<TransactionResult>, which should be handled as a normal Reactor Mono.

Parameters:

transactionLogic - the application's transaction logic

options - the configuration to use for this transaction

Returns:

there is no need to check the returned TransactionResult, as success is implied by the lack of a thrown exception. It contains information useful only for debugging and logging.

Throws:

TransactionFailedException - or a derived exception if the transaction fails to commit for any reason, possibly after multiple retries. The exception contains further details of the error.

run

public Mono<TransactionResult> run(Function<ReactiveTransactionAttemptContext,Mono<?>> transactionLogic)

Convenience overload that runs run(java.util.function.Function<com.couchbase.client.java.transactions.ReactiveTransactionAttemptContext, reactor.core.publisher.Mono<?>>, com.couchbase.client.java.transactions.config.TransactionOptions) with a default PerTransactionConfig.