java.lang.Object
- org.springframework.transaction.reactive.GenericReactiveTransaction

All Implemented Interfaces:
ReactiveTransaction, TransactionExecution
```
public class GenericReactiveTransaction
extends Object
implements ReactiveTransaction
```
Default implementation of the ReactiveTransaction interface, used by AbstractReactiveTransactionManager. Based on the concept of an underlying "transaction object".
Holds all status information that AbstractReactiveTransactionManager needs internally, including a generic transaction object determined by the concrete transaction manager implementation.
NOTE: This is not intended for use with other ReactiveTransactionManager implementations, in particular not for mock transaction managers in testing environments.
Since:
5.2
Author:
Mark Paluch, Juergen Hoeller
See Also:
AbstractReactiveTransactionManager, getTransaction()

Constructor Summary

Constructors
Constructor	Description
`GenericReactiveTransaction(Object transaction, boolean newTransaction, boolean newSynchronization, boolean readOnly, boolean debug, Object suspendedResources)`	Create a new `DefaultReactiveTransactionStatus` instance.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Object`	`getSuspendedResources()`	Return the holder for resources that have been suspended for this transaction, if any.
`Object`	`getTransaction()`	Return the underlying transaction object.
`boolean`	`hasTransaction()`	Return whether there is an actual transaction active.
`boolean`	`isCompleted()`	Return whether this transaction is completed, that is, whether it has already been committed or rolled back.
`boolean`	`isDebug()`	Return whether the progress of this transaction is debugged.
`boolean`	`isNewSynchronization()`	Return if a new transaction synchronization has been opened for this transaction.
`boolean`	`isNewTransaction()`	Return whether the present transaction is new; otherwise participating in an existing transaction, or potentially not running in an actual transaction in the first place.
`boolean`	`isReadOnly()`	Return if this transaction is defined as read-only transaction.
`boolean`	`isRollbackOnly()`	Determine the rollback-only flag via checking this ReactiveTransactionStatus.
`void`	`setCompleted()`	Mark this transaction as completed, that is, committed or rolled back.
`void`	`setRollbackOnly()`	Set the transaction rollback-only.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - GenericReactiveTransaction
```
public GenericReactiveTransaction(@Nullable
                                  Object transaction,
                                  boolean newTransaction,
                                  boolean newSynchronization,
                                  boolean readOnly,
                                  boolean debug,
                                  @Nullable
                                  Object suspendedResources)
```
    Create a new DefaultReactiveTransactionStatus instance.
    Parameters:
    transaction - underlying transaction object that can hold state for the internal transaction implementation
    newTransaction - if the transaction is new, otherwise participating in an existing transaction
    newSynchronization - if a new transaction synchronization has been opened for the given transaction
    readOnly - whether the transaction is marked as read-only
    debug - should debug logging be enabled for the handling of this transaction? Caching it in here can prevent repeated calls to ask the logging system whether debug logging should be enabled.
    suspendedResources - a holder for resources that have been suspended for this transaction, if any
- Method Detail
  - getTransaction
```
public Object getTransaction()
```
    Return the underlying transaction object.
    Throws:
    IllegalStateException - if no transaction is active
  - hasTransaction
```
public boolean hasTransaction()
```
    Return whether there is an actual transaction active.
  - isNewTransaction
```
public boolean isNewTransaction()
```
    Description copied from interface: TransactionExecution
    Return whether the present transaction is new; otherwise participating in an existing transaction, or potentially not running in an actual transaction in the first place.
    Specified by:
    isNewTransaction in interface TransactionExecution
  - isNewSynchronization
```
public boolean isNewSynchronization()
```
    Return if a new transaction synchronization has been opened for this transaction.
  - isReadOnly
```
public boolean isReadOnly()
```
    Return if this transaction is defined as read-only transaction.
  - isDebug
```
public boolean isDebug()
```
    Return whether the progress of this transaction is debugged. This is used by AbstractReactiveTransactionManager as an optimization, to prevent repeated calls to logger.isDebugEnabled(). Not really intended for client code.
  - getSuspendedResources
```
@Nullable
public Object getSuspendedResources()
```
    Return the holder for resources that have been suspended for this transaction, if any.
  - setRollbackOnly
```
public void setRollbackOnly()
```
    Description copied from interface: TransactionExecution
    Set the transaction rollback-only. This instructs the transaction manager that the only possible outcome of the transaction may be a rollback, as alternative to throwing an exception which would in turn trigger a rollback.
    Specified by:
    setRollbackOnly in interface TransactionExecution
  - isRollbackOnly
```
public boolean isRollbackOnly()
```
    Determine the rollback-only flag via checking this ReactiveTransactionStatus.
    Will only return "true" if the application called setRollbackOnly on this TransactionStatus object.
    Specified by:
    isRollbackOnly in interface TransactionExecution
  - setCompleted
```
public void setCompleted()
```
    Mark this transaction as completed, that is, committed or rolled back.
  - isCompleted
```
public boolean isCompleted()
```
    Description copied from interface: TransactionExecution
    Return whether this transaction is completed, that is, whether it has already been committed or rolled back.
    Specified by:
    isCompleted in interface TransactionExecution

Class GenericReactiveTransaction

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GenericReactiveTransaction

Method Detail

getTransaction

hasTransaction

isNewTransaction

isNewSynchronization

isReadOnly

isDebug

getSuspendedResources

setRollbackOnly

isRollbackOnly

setCompleted

isCompleted