AbstractSynchronousStateTransactionManager (data-parent 3.4.1 API)

java.lang.Object
- io.micronaut.transaction.support.AbstractSynchronousStateTransactionManager<T>

Type Parameters:

T - The resource type

All Implemented Interfaces:

java.io.Serializable

Direct Known Subclasses:

AbstractSynchronousTransactionManager
```
@Internal
public abstract class AbstractSynchronousStateTransactionManager<T>
extends java.lang.Object
implements java.io.Serializable
```
NOTICE: This is a fork of Spring's AbstractPlatformTransactionManager modernizing it to use enums, Slf4j and decoupling from Spring.
Abstract base class that implements standard transaction workflow, serving as basis for concrete platform transaction managers.
This base class provides the following workflow handling:
- determines if there is an existing transaction;
- applies the appropriate propagation behavior;
- suspends and resumes transactions if necessary;
- checks the rollback-only flag on commit;
- applies the appropriate modification on rollback (actual rollback or setting rollback-only);
- triggers registered synchronization callbacks (if transaction synchronization is active).
Subclasses have to implement specific template methods for specific states of a transaction, e.g.: begin, suspend, resume, commit, rollback. The most important of them are abstract and must be provided by a concrete implementation; for the rest, defaults are provided, so overriding is optional.
Transaction synchronization is a generic mechanism for registering callbacks that get invoked at transaction completion time. This is mainly used internally by the data access support classes for JDBC, Hibernate, JPA, etc when running within a JTA transaction: They register resources that are opened within the transaction for closing at transaction completion time, allowing e.g. for reuse of the same Hibernate Session within the transaction. The same mechanism can also be leveraged for custom synchronization needs in an application.
The state of this class is serializable, to allow for serializing the transaction strategy along with proxies that carry a transaction interceptor. It is up to subclasses if they wish to make their state to be serializable too. They should implement the java.io.Serializable marker interface in that case, and potentially a private readObject() method (according to Java serialization rules) if they need to restore any transient state.
Since:

28.03.2003, 3.4.0

Author:

Juergen Hoeller, graemerocher, Denis Stepanov

See Also:

setTransactionSynchronization(io.micronaut.transaction.support.AbstractSynchronousStateTransactionManager.Synchronization), TransactionSynchronizationManager, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class AbstractSynchronousStateTransactionManager.SuspendedResourcesHolder
Holder for suspended resources.

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AbstractSynchronousStateTransactionManager.SuspendedResourcesHolder` Holder for suspended resources.

Field Summary

Fields
Modifier and Type Field and Description

protected org.slf4j.Logger logger

Fields
Modifier and Type	Field and Description
`protected org.slf4j.Logger`	`logger`

Constructor Summary

Constructors
Constructor and Description

AbstractSynchronousStateTransactionManager()

Constructors
Constructor and Description
`AbstractSynchronousStateTransactionManager()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`commit(SynchronousTransactionState state, TransactionStatus<T> status)` Commit the given transaction, with regard to its status.
`protected java.time.Duration`	`determineTimeout(TransactionDefinition definition)` Determine the actual timeout to use for the given definition.
`protected abstract void`	`doBegin(java.lang.Object transaction, TransactionDefinition definition)` Begin a new transaction with semantics according to the given transaction definition.
`protected void`	`doCleanupAfterCompletion(SynchronousTransactionState state, java.lang.Object transaction)` Cleanup resources after transaction completion.
`protected abstract void`	`doCommit(DefaultTransactionStatus<T> status)` Perform an actual commit of the given transaction.
`protected void`	`doDestroyState(SynchronousTransactionState state)` Destroy the state.
`protected abstract java.lang.Object`	`doGetTransaction(SynchronousTransactionState state)` Return a transaction object for the current transaction state.
`protected void`	`doResume(java.lang.Object transaction, java.lang.Object suspendedResources)` Resume the resources of the current transaction.
`protected abstract void`	`doRollback(DefaultTransactionStatus<T> status)` Perform an actual rollback of the given transaction.
`protected void`	`doSetRollbackOnly(DefaultTransactionStatus<T> status)` Set the given transaction rollback-only.
`protected java.lang.Object`	`doSuspend(java.lang.Object transaction)` Suspend the resources of the current transaction.
`<R> R`	`execute(SynchronousTransactionState state, TransactionDefinition definition, TransactionCallback<T,R> callback)` Execute a read-only transaction within the context of the function.
`<R> R`	`executeRead(SynchronousTransactionState state, TransactionCallback<T,R> callback)` Execute a read-only transaction within the context of the function.
`<R> R`	`executeWrite(SynchronousTransactionState state, TransactionCallback<T,R> callback)` Execute a default transaction within the context of the function.
`protected abstract T`	`getConnection(SynchronousTransactionState state, java.lang.Object transaction)` The connection for the given transaction object.
`java.time.Duration`	`getDefaultTimeout()` Return the default timeout that this transaction manager should apply if there is no timeout specified at the transaction level, in seconds.
`TransactionStatus<T>`	`getTransaction(SynchronousTransactionState state, TransactionDefinition definition)` This implementation handles propagation behavior.
`io.micronaut.transaction.support.AbstractSynchronousStateTransactionManager.Synchronization`	`getTransactionSynchronization()` Return if this transaction manager should activate the thread-bound transaction synchronization support.
`protected void`	`invokeAfterCompletion(SynchronousTransactionState state, java.util.List<TransactionSynchronization> synchronizations, TransactionSynchronization.Status completionStatus)` Actually invoke the `afterCompletion` methods of the given Spring TransactionSynchronization objects.
`protected boolean`	`isExistingTransaction(SynchronousTransactionState state, java.lang.Object transaction)` Check if the given transaction object indicates an existing transaction (that is, a transaction which has already started).
`boolean`	`isFailEarlyOnGlobalRollbackOnly()`
`boolean`	`isGlobalRollbackOnParticipationFailure()`
`boolean`	`isNestedTransactionAllowed()`
`boolean`	`isRollbackOnCommitFailure()`
`boolean`	`isValidateExistingTransaction()` Return whether existing transactions should be validated before participating in them.
`protected DefaultTransactionStatus<T>`	`newTransactionStatus(SynchronousTransactionState state, TransactionDefinition definition, java.lang.Object transaction, boolean newTransaction, boolean newSynchronization, boolean debug, java.lang.Object suspendedResources)` Create a TransactionStatus instance for the given arguments.
`protected void`	`prepareForCommit(DefaultTransactionStatus<T> status)` Make preparations for commit, to be performed before the `beforeCommit` synchronization callbacks occur.
`protected void`	`prepareSynchronization(SynchronousTransactionState state, DefaultTransactionStatus<T> status, TransactionDefinition definition)` Initialize transaction synchronization as appropriate.
`protected DefaultTransactionStatus<T>`	`prepareTransactionStatus(SynchronousTransactionState state, TransactionDefinition definition, java.lang.Object transaction, boolean newTransaction, boolean newSynchronization, boolean debug, java.lang.Object suspendedResources)` Create a new TransactionStatus for the given arguments, also initializing transaction synchronization as appropriate.
`protected void`	`registerAfterCompletionWithExistingTransaction(SynchronousTransactionState state, java.lang.Object transaction, java.util.List<TransactionSynchronization> synchronizations)` Register the given list of transaction synchronizations with the existing transaction.
`protected void`	`resume(SynchronousTransactionState state, java.lang.Object transaction, AbstractSynchronousStateTransactionManager.SuspendedResourcesHolder resourcesHolder)` Resume the given transaction.
`void`	`rollback(SynchronousTransactionState state, TransactionStatus<T> status)` Perform a rollback of the given transaction.
`void`	`setDefaultTimeout(java.time.Duration defaultTimeout)` Specify the default timeout that this transaction manager should apply if there is no timeout specified at the transaction level, in seconds.
`void`	`setFailEarlyOnGlobalRollbackOnly(boolean failEarlyOnGlobalRollbackOnly)` Set whether to fail early in case of the transaction being globally marked as rollback-only.
`void`	`setGlobalRollbackOnParticipationFailure(boolean globalRollbackOnParticipationFailure)` Set whether to globally mark an existing transaction as rollback-only after a participating transaction failed.
`void`	`setNestedTransactionAllowed(boolean nestedTransactionAllowed)` Set whether nested transactions are allowed.
`void`	`setRollbackOnCommitFailure(boolean rollbackOnCommitFailure)` Set whether `doRollback` should be performed on failure of the `doCommit` call.
`void`	`setTransactionSynchronization(io.micronaut.transaction.support.AbstractSynchronousStateTransactionManager.Synchronization transactionSynchronization)` Set when this transaction manager should activate the thread-bound transaction synchronization support.
`void`	`setValidateExistingTransaction(boolean validateExistingTransaction)` Set whether existing transactions should be validated before participating in them.
`protected boolean`	`shouldCommitOnGlobalRollbackOnly()` Return whether to call `doCommit` on a transaction that has been marked as rollback-only in a global fashion.
`protected AbstractSynchronousStateTransactionManager.SuspendedResourcesHolder`	`suspend(SynchronousTransactionState state, java.lang.Object transaction)` Suspend the given transaction.
`protected void`	`triggerBeforeCommit(SynchronousTransactionState state, DefaultTransactionStatus<T> status)` Trigger `beforeCommit` callbacks.
`protected void`	`triggerBeforeCompletion(SynchronousTransactionState state, DefaultTransactionStatus<T> status)` Trigger `beforeCompletion` callbacks.
`protected boolean`	`useSavepointForNestedTransaction()` Return whether to use a savepoint for a nested transaction.

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

- Field Detail
  - logger
```
protected transient org.slf4j.Logger logger
```
- Constructor Detail
  - AbstractSynchronousStateTransactionManager
```
public AbstractSynchronousStateTransactionManager()
```
- Method Detail
  - execute
```
public <R> R execute(@NonNull
                     SynchronousTransactionState state,
                     @NonNull
                     TransactionDefinition definition,
                     @NonNull
                     TransactionCallback<T,R> callback)
```
    Description copied from interface: TransactionStateOperations
    
    Execute a read-only transaction within the context of the function.
    
    Type Parameters:
    
    R - The result
    
    Parameters:
    
    state - The transaction state
    
    definition - The transaction definition
    
    callback - The call back
    
    Returns:
    
    The result
  - executeRead
```
public <R> R executeRead(@NonNull
                         SynchronousTransactionState state,
                         @NonNull
                         TransactionCallback<T,R> callback)
```
    Description copied from interface: TransactionStateOperations
    
    Execute a read-only transaction within the context of the function.
    
    Type Parameters:
    
    R - The result
    
    Parameters:
    
    state - The transaction state
    
    callback - The call back
    
    Returns:
    
    The result
  - executeWrite
```
public <R> R executeWrite(@NonNull
                          SynchronousTransactionState state,
                          @NonNull
                          TransactionCallback<T,R> callback)
```
    Description copied from interface: TransactionStateOperations
    
    Execute a default transaction within the context of the function.
    
    Type Parameters:
    
    R - The result
    
    Parameters:
    
    state - The transaction state
    
    callback - The call back
    
    Returns:
    
    The result
  - setTransactionSynchronization
```
public final void setTransactionSynchronization(@NonNull
                                                io.micronaut.transaction.support.AbstractSynchronousStateTransactionManager.Synchronization transactionSynchronization)
```
    Set when this transaction manager should activate the thread-bound transaction synchronization support. Default is "always".
    Note that transaction synchronization isn't supported for multiple concurrent transactions by different transaction managers. Only one transaction manager is allowed to activate it at any time.
    
    Parameters:
    
    transactionSynchronization - the synchronization to use
    
    See Also:
    
    Synchronization#ALWAYS, Synchronization#ON_ACTUAL_TRANSACTION, Synchronization#NEVER, TransactionSynchronization
  - getTransactionSynchronization
```
@NonNull
public final io.micronaut.transaction.support.AbstractSynchronousStateTransactionManager.Synchronization getTransactionSynchronization()
```
    Return if this transaction manager should activate the thread-bound transaction synchronization support.
    
    Returns:
    
    The current synchronization
  - setDefaultTimeout
```
public final void setDefaultTimeout(@NonNull
                                    java.time.Duration defaultTimeout)
```
    Specify the default timeout that this transaction manager should apply if there is no timeout specified at the transaction level, in seconds.
    Default is the underlying transaction infrastructure's default timeout, e.g. typically 30 seconds in case of a JTA provider, indicated by the TransactionDefinition.TIMEOUT_DEFAULT value.
    
    Parameters:
    
    defaultTimeout - The default timeout
    
    See Also:
    
    TransactionDefinition.TIMEOUT_DEFAULT
  - getDefaultTimeout
```
@NonNull
public final java.time.Duration getDefaultTimeout()
```
    Return the default timeout that this transaction manager should apply if there is no timeout specified at the transaction level, in seconds.
    Returns TransactionDefinition.TIMEOUT_DEFAULT to indicate the underlying transaction infrastructure's default timeout.
    
    Returns:
    
    The default timeout
  - setNestedTransactionAllowed
```
public final void setNestedTransactionAllowed(boolean nestedTransactionAllowed)
```
    Set whether nested transactions are allowed. Default is "false".
    Typically initialized with an appropriate default by the concrete transaction manager subclass.
    
    Parameters:
    
    nestedTransactionAllowed - Whether a nested transaction is allowed
  - isNestedTransactionAllowed
```
public final boolean isNestedTransactionAllowed()
```
    Returns:
    
    Return whether nested transactions are allowed.
  - setValidateExistingTransaction
```
public final void setValidateExistingTransaction(boolean validateExistingTransaction)
```
    Set whether existing transactions should be validated before participating in them.
    When participating in an existing transaction (e.g. with PROPAGATION_REQUIRED or PROPAGATION_SUPPORTS encountering an existing transaction), this outer transaction's characteristics will apply even to the inner transaction scope. Validation will detect incompatible isolation level and read-only settings on the inner transaction definition and reject participation accordingly through throwing a corresponding exception.
    Default is "false", leniently ignoring inner transaction settings, simply overriding them with the outer transaction's characteristics. Switch this flag to "true" in order to enforce strict validation.
    
    Parameters:
    
    validateExistingTransaction - Whether to validate an existing transaction
    
    Since:
    
    2.5.1
  - isValidateExistingTransaction
```
public final boolean isValidateExistingTransaction()
```
    Return whether existing transactions should be validated before participating in them.
    
    Returns:
    
    Whether to validate existing transactions
    
    Since:
    
    2.5.1
  - setGlobalRollbackOnParticipationFailure
```
public final void setGlobalRollbackOnParticipationFailure(boolean globalRollbackOnParticipationFailure)
```
    Set whether to globally mark an existing transaction as rollback-only after a participating transaction failed.
    Default is "true": If a participating transaction (e.g. with PROPAGATION_REQUIRED or PROPAGATION_SUPPORTS encountering an existing transaction) fails, the transaction will be globally marked as rollback-only. The only possible outcome of such a transaction is a rollback: The transaction originator cannot make the transaction commit anymore.
    Switch this to "false" to let the transaction originator make the rollback decision. If a participating transaction fails with an exception, the caller can still decide to continue with a different path within the transaction. However, note that this will only work as long as all participating resources are capable of continuing towards a transaction commit even after a data access failure: This is generally not the case for a Hibernate Session, for example; neither is it for a sequence of JDBC insert/update/delete operations.
    Note:This flag only applies to an explicit rollback attempt for a subtransaction, typically caused by an exception thrown by a data access operation (where TransactionInterceptor will trigger a PlatformTransactionManager.rollback() call according to a rollback rule). If the flag is off, the caller can handle the exception and decide on a rollback, independent of the rollback rules of the subtransaction. This flag does, however, not apply to explicit setRollbackOnly calls on a TransactionStatus, which will always cause an eventual global rollback (as it might not throw an exception after the rollback-only call).
    The recommended solution for handling failure of a subtransaction is a "nested transaction", where the global transaction can be rolled back to a savepoint taken at the beginning of the subtransaction. PROPAGATION_NESTED provides exactly those semantics; however, it will only work when nested transaction support is available. This is the case with DataSourceTransactionManager, but not with JtaTransactionManager.
    
    Parameters:
    
    globalRollbackOnParticipationFailure - Whether to globally mark transaction as rollback only
    
    See Also:
    
    setNestedTransactionAllowed(boolean)
  - isGlobalRollbackOnParticipationFailure
```
public final boolean isGlobalRollbackOnParticipationFailure()
```
    Returns:
    
    Return whether to globally mark an existing transaction as rollback-only after a participating transaction failed.
  - setFailEarlyOnGlobalRollbackOnly
```
public final void setFailEarlyOnGlobalRollbackOnly(boolean failEarlyOnGlobalRollbackOnly)
```
    Set whether to fail early in case of the transaction being globally marked as rollback-only.
    Default is "false", only causing an UnexpectedRollbackException at the outermost transaction boundary. Switch this flag on to cause an UnexpectedRollbackException as early as the global rollback-only marker has been first detected, even from within an inner transaction boundary.
    
    Parameters:
    
    failEarlyOnGlobalRollbackOnly - Sets whether to fail early on global rollback
    
    Since:
    
    2.0
    
    See Also:
    
    UnexpectedRollbackException
  - isFailEarlyOnGlobalRollbackOnly
```
public final boolean isFailEarlyOnGlobalRollbackOnly()
```
    Returns:
    
    Return whether to fail early in case of the transaction being globally marked as rollback-only.
    
    Since:
    
    2.0
  - setRollbackOnCommitFailure
```
public final void setRollbackOnCommitFailure(boolean rollbackOnCommitFailure)
```
    Set whether doRollback should be performed on failure of the doCommit call. Typically not necessary and thus to be avoided, as it can potentially override the commit exception with a subsequent rollback exception.
    Default is "false".
    
    Parameters:
    
    rollbackOnCommitFailure - Sets whether to rollback on commit failure
    
    See Also:
    
    doCommit(io.micronaut.transaction.support.DefaultTransactionStatus<T>), doRollback(io.micronaut.transaction.support.DefaultTransactionStatus<T>)
  - isRollbackOnCommitFailure
```
public final boolean isRollbackOnCommitFailure()
```
    Returns:
    
    Return whether doRollback should be performed on failure of the doCommit call.
  - getTransaction
```
@NonNull
public final TransactionStatus<T> getTransaction(@NonNull
                                                          SynchronousTransactionState state,
                                                          @Nullable
                                                          TransactionDefinition definition)
                                                   throws TransactionException
```
    This implementation handles propagation behavior. Delegates to doGetTransaction, isExistingTransaction and doBegin.
    
    Parameters:
    
    state - the transaction state
    
    definition - the TransactionDefinition instance (can be null for defaults), describing propagation behavior, isolation level, timeout etc.
    
    Returns:
    
    transaction status object representing the new or current transaction
    
    Throws:
    
    TransactionException - in case of lookup, creation, or system errors
    
    IllegalTransactionStateException - if the given transaction definition cannot be executed (for example, if a currently active transaction is in conflict with the specified propagation behavior)
    
    See Also:
    
    doGetTransaction(io.micronaut.transaction.support.SynchronousTransactionState), isExistingTransaction(io.micronaut.transaction.support.SynchronousTransactionState, java.lang.Object), doBegin(java.lang.Object, io.micronaut.transaction.TransactionDefinition)
  - prepareTransactionStatus
```
protected final DefaultTransactionStatus<T> prepareTransactionStatus(@NonNull
                                                                     SynchronousTransactionState state,
                                                                     TransactionDefinition definition,
                                                                     @Nullable
                                                                     java.lang.Object transaction,
                                                                     boolean newTransaction,
                                                                     boolean newSynchronization,
                                                                     boolean debug,
                                                                     @Nullable
                                                                     java.lang.Object suspendedResources)
```
    Create a new TransactionStatus for the given arguments, also initializing transaction synchronization as appropriate.
    
    Parameters:
    
    state - The transaction state
    
    definition - The definition
    
    transaction - The transaction object
    
    newTransaction - Is this is a new transaction
    
    newSynchronization - Is this a new synchronization
    
    debug - Is debug enabled
    
    suspendedResources - Any suspended resources
    
    Returns:
    
    The status
    
    See Also:
    
    newTransactionStatus(io.micronaut.transaction.support.SynchronousTransactionState, io.micronaut.transaction.TransactionDefinition, java.lang.Object, boolean, boolean, boolean, java.lang.Object), prepareTransactionStatus(io.micronaut.transaction.support.SynchronousTransactionState, io.micronaut.transaction.TransactionDefinition, java.lang.Object, boolean, boolean, boolean, java.lang.Object)
  - newTransactionStatus
```
protected DefaultTransactionStatus<T> newTransactionStatus(@NonNull
                                                           SynchronousTransactionState state,
                                                           TransactionDefinition definition,
                                                           @Nullable
                                                           java.lang.Object transaction,
                                                           boolean newTransaction,
                                                           boolean newSynchronization,
                                                           boolean debug,
                                                           @Nullable
                                                           java.lang.Object suspendedResources)
```
    Create a TransactionStatus instance for the given arguments.
    
    Parameters:
    
    state - The transaction state
    
    definition - The definition
    
    transaction - The transaction object
    
    newTransaction - Is this is a new transaction
    
    newSynchronization - Is this a new synchronization
    
    debug - Is debug enabled
    
    suspendedResources - Any suspended resources
    
    Returns:
    
    The status
  - getConnection
```
@Nullable
protected abstract T getConnection(@NonNull
                                             SynchronousTransactionState state,
                                             java.lang.Object transaction)
```
    The connection for the given transaction object.
    
    Parameters:
    
    state - The transaction state
    
    transaction - The transaction
    
    Returns:
    
    The connection.
  - prepareSynchronization
```
protected void prepareSynchronization(@NonNull
                                      SynchronousTransactionState state,
                                      @NonNull
                                      DefaultTransactionStatus<T> status,
                                      @NonNull
                                      TransactionDefinition definition)
```
    Initialize transaction synchronization as appropriate.
    
    Parameters:
    
    state - The transaction state
    
    status - The status
    
    definition - The definition
  - determineTimeout
```
protected java.time.Duration determineTimeout(TransactionDefinition definition)
```
    Determine the actual timeout to use for the given definition. Will fall back to this manager's default timeout if the transaction definition doesn't specify a non-default value.
    
    Parameters:
    
    definition - the transaction definition
    
    Returns:
    
    the actual timeout to use
    
    See Also:
    
    TransactionDefinition.getTimeout(), setDefaultTimeout(java.time.Duration)
  - suspend
```
@Nullable
protected final AbstractSynchronousStateTransactionManager.SuspendedResourcesHolder suspend(@NonNull
                                                                                                      SynchronousTransactionState state,
                                                                                                      @Nullable
                                                                                                      java.lang.Object transaction)
                                                                                               throws TransactionException
```
    Suspend the given transaction. Suspends transaction synchronization first, then delegates to the doSuspend template method.
    
    Parameters:
    
    state - The transaction state
    
    transaction - the current transaction object (or null to just suspend active synchronizations, if any)
    
    Returns:
    
    an object that holds suspended resources (or null if neither transaction nor synchronization active)
    
    Throws:
    
    TransactionException - Thrown if an error occurs suspending the transaction
    
    See Also:
    
    doSuspend(java.lang.Object), resume(io.micronaut.transaction.support.SynchronousTransactionState, java.lang.Object, io.micronaut.transaction.support.AbstractSynchronousStateTransactionManager.SuspendedResourcesHolder)
  - resume
```
protected final void resume(@NonNull
                            SynchronousTransactionState state,
                            @Nullable
                            java.lang.Object transaction,
                            @Nullable
                            AbstractSynchronousStateTransactionManager.SuspendedResourcesHolder resourcesHolder)
                     throws TransactionException
```
    Resume the given transaction. Delegates to the doResume template method first, then resuming transaction synchronization.
    
    Parameters:
    
    state - The transaction state
    
    transaction - the current transaction object
    
    resourcesHolder - the object that holds suspended resources, as returned by suspend (or null to just resume synchronizations, if any)
    
    Throws:
    
    TransactionException - Thrown if an error occurs resuming the transaction
    
    See Also:
    
    doResume(java.lang.Object, java.lang.Object), suspend(io.micronaut.transaction.support.SynchronousTransactionState, java.lang.Object)
  - commit
```
public final void commit(@NonNull
                         SynchronousTransactionState state,
                         TransactionStatus<T> status)
                  throws TransactionException
```
    Commit the given transaction, with regard to its status. If the transaction has been marked rollback-only programmatically, perform a rollback.
    If the transaction wasn't a new one, omit the commit for proper participation in the surrounding transaction. If a previous transaction has been suspended to be able to create a new one, resume the previous transaction after committing the new one.
    Note that when the commit call completes, no matter if normally or throwing an exception, the transaction must be fully completed and cleaned up. No rollback call should be expected in such a case.
    If this method throws an exception other than a TransactionException, then some before-commit error caused the commit attempt to fail. For example, an O/R Mapping tool might have tried to flush changes to the database right before commit, with the resulting DataAccessException causing the transaction to fail. The original exception will be propagated to the caller of this commit method in such a case.
    
    Parameters:
    
    state - the transaction state
    
    status - object returned by the getTransaction method
    
    Throws:
    
    UnexpectedRollbackException - in case of an unexpected rollback that the transaction coordinator initiated
    
    HeuristicCompletionException - in case of a transaction failure caused by a heuristic decision on the side of the transaction coordinator
    
    TransactionSystemException - in case of commit or system errors (typically caused by fundamental resource failures)
    
    IllegalTransactionStateException - if the given transaction is already completed (that is, committed or rolled back)
    
    TransactionException - if something goes wrong during commit
    
    See Also:
    
    TransactionExecution.setRollbackOnly()
  - rollback
```
public final void rollback(@NonNull
                           SynchronousTransactionState state,
                           TransactionStatus<T> status)
                    throws TransactionException
```
    Perform a rollback of the given transaction.
    If the transaction wasn't a new one, just set it rollback-only for proper participation in the surrounding transaction. If a previous transaction has been suspended to be able to create a new one, resume the previous transaction after rolling back the new one.
    Do not call rollback on a transaction if commit threw an exception. The transaction will already have been completed and cleaned up when commit returns, even in case of a commit exception. Consequently, a rollback call after commit failure will lead to an IllegalTransactionStateException.
    
    Parameters:
    
    state - the transaction state
    
    status - object returned by the getTransaction method
    
    Throws:
    
    TransactionSystemException - in case of rollback or system errors (typically caused by fundamental resource failures)
    
    IllegalTransactionStateException - if the given transaction is already completed (that is, committed or rolled back)
    
    TransactionException - if something goes wrong during rollback
  - triggerBeforeCommit
```
protected final void triggerBeforeCommit(@NonNull
                                         SynchronousTransactionState state,
                                         @NonNull
                                         DefaultTransactionStatus<T> status)
```
    Trigger beforeCommit callbacks.
    
    Parameters:
    
    state - The transaction state
    
    status - object representing the transaction
  - triggerBeforeCompletion
```
protected final void triggerBeforeCompletion(@NonNull
                                             SynchronousTransactionState state,
                                             @NonNull
                                             DefaultTransactionStatus<T> status)
```
    Trigger beforeCompletion callbacks.
    
    Parameters:
    
    state - The transaction state
    
    status - object representing the transaction
  - invokeAfterCompletion
```
protected final void invokeAfterCompletion(@NonNull
                                           SynchronousTransactionState state,
                                           java.util.List<TransactionSynchronization> synchronizations,
                                           TransactionSynchronization.Status completionStatus)
```
    Actually invoke the afterCompletion methods of the given Spring TransactionSynchronization objects.
    To be called by this abstract manager itself, or by special implementations of the registerAfterCompletionWithExistingTransaction callback.
    
    Parameters:
    
    state - The transaction state
    
    synchronizations - a List of TransactionSynchronization objects
    
    completionStatus - the completion status according to the constants in the TransactionSynchronization interface
    
    See Also:
    
    registerAfterCompletionWithExistingTransaction(SynchronousTransactionState, Object, List), TransactionSynchronization.Status.COMMITTED, TransactionSynchronization.Status.ROLLED_BACK, TransactionSynchronization.Status.UNKNOWN
  - doGetTransaction
```
@NonNull
protected abstract java.lang.Object doGetTransaction(@NonNull
                                                              SynchronousTransactionState state)
                                                       throws TransactionException
```
    Return a transaction object for the current transaction state.
    The returned object will usually be specific to the concrete transaction manager implementation, carrying corresponding transaction state in a modifiable fashion. This object will be passed into the other template methods (e.g. doBegin and doCommit), either directly or as part of a DefaultTransactionStatus instance.
    The returned object should contain information about any existing transaction, that is, a transaction that has already started before the current getTransaction call on the transaction manager. Consequently, a doGetTransaction implementation will usually look for an existing transaction and store corresponding state in the returned transaction object.
    
    Parameters:
    
    state - The transaction state
    
    Returns:
    
    the current transaction object
    
    Throws:
    
    CannotCreateTransactionException - if transaction support is not available
    
    TransactionException - in case of lookup or system errors
    
    See Also:
    
    doBegin(java.lang.Object, io.micronaut.transaction.TransactionDefinition), doCommit(io.micronaut.transaction.support.DefaultTransactionStatus<T>), doRollback(io.micronaut.transaction.support.DefaultTransactionStatus<T>), DefaultTransactionStatus.getTransaction()
  - isExistingTransaction
```
protected boolean isExistingTransaction(@NonNull
                                        SynchronousTransactionState state,
                                        @NonNull
                                        java.lang.Object transaction)
                                 throws TransactionException
```
    Check if the given transaction object indicates an existing transaction (that is, a transaction which has already started).
    The result will be evaluated according to the specified propagation behavior for the new transaction. An existing transaction might get suspended (in case of PROPAGATION_REQUIRES_NEW), or the new transaction might participate in the existing one (in case of PROPAGATION_REQUIRED).
    The default implementation returns false, assuming that participating in existing transactions is generally not supported. Subclasses are of course encouraged to provide such support.
    
    Parameters:
    
    state - The transaction state
    
    transaction - transaction object returned by doGetTransaction
    
    Returns:
    
    if there is an existing transaction
    
    Throws:
    
    TransactionException - in case of system errors
    
    See Also:
    
    doGetTransaction(io.micronaut.transaction.support.SynchronousTransactionState)
  - useSavepointForNestedTransaction
```
protected boolean useSavepointForNestedTransaction()
```
    Return whether to use a savepoint for a nested transaction.
    Default is true, which causes delegation to DefaultTransactionStatus for creating and holding a savepoint. If the transaction object does not implement the SavepointManager interface, a NestedTransactionNotSupportedException will be thrown. Else, the SavepointManager will be asked to create a new savepoint to demarcate the start of the nested transaction.
    Subclasses can override this to return false, causing a further call to doBegin - within the context of an already existing transaction. The doBegin implementation needs to handle this accordingly in such a scenario. This is appropriate for JTA, for example.
    
    Returns:
    
    Whether to use save points for nested transactions
    
    See Also:
    
    AbstractTransactionStatus.createAndHoldSavepoint(), AbstractTransactionStatus.rollbackToHeldSavepoint(), AbstractTransactionStatus.releaseHeldSavepoint(), doBegin(java.lang.Object, io.micronaut.transaction.TransactionDefinition)
  - doBegin
```
protected abstract void doBegin(@NonNull
                                java.lang.Object transaction,
                                TransactionDefinition definition)
                         throws TransactionException
```
    Begin a new transaction with semantics according to the given transaction definition. Does not have to care about applying the propagation behavior, as this has already been handled by this abstract manager.
    This method gets called when the transaction manager has decided to actually start a new transaction. Either there wasn't any transaction before, or the previous transaction has been suspended.
    A special scenario is a nested transaction without savepoint: If useSavepointForNestedTransaction() returns "false", this method will be called to start a nested transaction when necessary. In such a context, there will be an active transaction: The implementation of this method has to detect this and start an appropriate nested transaction.
    
    Parameters:
    
    transaction - transaction object returned by doGetTransaction
    
    definition - a TransactionDefinition instance, describing propagation behavior, isolation level, read-only flag, timeout, and transaction name
    
    Throws:
    
    TransactionException - in case of creation or system errors
    
    NestedTransactionNotSupportedException - if the underlying transaction does not support nesting
  - doSuspend
```
@Nullable
protected java.lang.Object doSuspend(@NonNull
                                               java.lang.Object transaction)
                                        throws TransactionException
```
    Suspend the resources of the current transaction. Transaction synchronization will already have been suspended.
    The default implementation throws a TransactionSuspensionNotSupportedException, assuming that transaction suspension is generally not supported.
    
    Parameters:
    
    transaction - transaction object returned by doGetTransaction
    
    Returns:
    
    an object that holds suspended resources (will be kept unexamined for passing it into doResume)
    
    Throws:
    
    TransactionSuspensionNotSupportedException - if suspending is not supported by the transaction manager implementation
    
    TransactionException - in case of system errors
    
    See Also:
    
    doResume(java.lang.Object, java.lang.Object)
  - doResume
```
protected void doResume(@Nullable
                        java.lang.Object transaction,
                        @NonNull
                        java.lang.Object suspendedResources)
                 throws TransactionException
```
    Resume the resources of the current transaction. Transaction synchronization will be resumed afterwards.
    The default implementation throws a TransactionSuspensionNotSupportedException, assuming that transaction suspension is generally not supported.
    
    Parameters:
    
    transaction - transaction object returned by doGetTransaction
    
    suspendedResources - the object that holds suspended resources, as returned by doSuspend
    
    Throws:
    
    TransactionSuspensionNotSupportedException - if resuming is not supported by the transaction manager implementation
    
    TransactionException - in case of system errors
    
    See Also:
    
    doSuspend(java.lang.Object)
  - shouldCommitOnGlobalRollbackOnly
```
protected boolean shouldCommitOnGlobalRollbackOnly()
```
    Return whether to call doCommit on a transaction that has been marked as rollback-only in a global fashion.
    Does not apply if an application locally sets the transaction to rollback-only via the TransactionStatus, but only to the transaction itself being marked as rollback-only by the transaction coordinator.
    Default is "false": Local transaction strategies usually don't hold the rollback-only marker in the transaction itself, therefore they can't handle rollback-only transactions as part of transaction commit. Hence, AbstractPlatformTransactionManager will trigger a rollback in that case, throwing an UnexpectedRollbackException afterwards.
    Override this to return "true" if the concrete transaction manager expects a doCommit call even for a rollback-only transaction, allowing for special handling there. This will, for example, be the case for JTA, where UserTransaction.commit will check the read-only flag itself and throw a corresponding RollbackException, which might include the specific reason (such as a transaction timeout).
    If this method returns "true" but the doCommit implementation does not throw an exception, this transaction manager will throw an UnexpectedRollbackException itself. This should not be the typical case; it is mainly checked to cover misbehaving JTA providers that silently roll back even when the rollback has not been requested by the calling code.
    
    Returns:
    
    Whether to call doCommit on a transaction that has been marked as rollback-only in a global fashion.
    
    See Also:
    
    doCommit(io.micronaut.transaction.support.DefaultTransactionStatus<T>), DefaultTransactionStatus.isGlobalRollbackOnly(), AbstractTransactionStatus.isLocalRollbackOnly(), TransactionExecution.setRollbackOnly(), UnexpectedRollbackException
  - prepareForCommit
```
protected void prepareForCommit(DefaultTransactionStatus<T> status)
```
    Make preparations for commit, to be performed before the beforeCommit synchronization callbacks occur.
    Note that exceptions will get propagated to the commit caller and cause a rollback of the transaction.
    
    Parameters:
    
    status - the status representation of the transaction
    
    Throws:
    
    java.lang.RuntimeException - in case of errors; will be propagated to the caller (note: do not throw TransactionException subclasses here!)
  - doCommit
```
protected abstract void doCommit(DefaultTransactionStatus<T> status)
                          throws TransactionException
```
    Perform an actual commit of the given transaction.
    An implementation does not need to check the "new transaction" flag or the rollback-only flag; this will already have been handled before. Usually, a straight commit will be performed on the transaction object contained in the passed-in status.
    
    Parameters:
    
    status - the status representation of the transaction
    
    Throws:
    
    TransactionException - in case of commit or system errors
    
    See Also:
    
    DefaultTransactionStatus.getTransaction()
  - doRollback
```
protected abstract void doRollback(DefaultTransactionStatus<T> status)
                            throws TransactionException
```
    Perform an actual rollback of the given transaction.
    An implementation does not need to check the "new transaction" flag; this will already have been handled before. Usually, a straight rollback will be performed on the transaction object contained in the passed-in status.
    
    Parameters:
    
    status - the status representation of the transaction
    
    Throws:
    
    TransactionException - in case of system errors
    
    See Also:
    
    DefaultTransactionStatus.getTransaction()
  - doSetRollbackOnly
```
protected void doSetRollbackOnly(DefaultTransactionStatus<T> status)
                          throws TransactionException
```
    Set the given transaction rollback-only. Only called on rollback if the current transaction participates in an existing one.
    The default implementation throws an IllegalTransactionStateException, assuming that participating in existing transactions is generally not supported. Subclasses are of course encouraged to provide such support.
    
    Parameters:
    
    status - the status representation of the transaction
    
    Throws:
    
    TransactionException - in case of system errors
  - registerAfterCompletionWithExistingTransaction
```
protected void registerAfterCompletionWithExistingTransaction(@NonNull
                                                              SynchronousTransactionState state,
                                                              java.lang.Object transaction,
                                                              java.util.List<TransactionSynchronization> synchronizations)
                                                       throws TransactionException
```
    Register the given list of transaction synchronizations with the existing transaction.
    Invoked when the control of the transaction manager and thus all transaction synchronizations end, without the transaction being completed yet. This is for example the case when participating in an existing JTA or EJB CMT transaction.
    The default implementation simply invokes the afterCompletion methods immediately, passing in "STATUS_UNKNOWN". This is the best we can do if there's no chance to determine the actual outcome of the outer transaction.
    
    Parameters:
    
    state - The transaction state
    
    transaction - transaction object returned by doGetTransaction
    
    synchronizations - a List of TransactionSynchronization objects
    
    Throws:
    
    TransactionException - in case of system errors
    
    See Also:
    
    invokeAfterCompletion(SynchronousTransactionState, List, TransactionSynchronization.Status), TransactionSynchronization.afterCompletion(TransactionSynchronization.Status), TransactionSynchronization.Status.UNKNOWN
  - doCleanupAfterCompletion
```
protected void doCleanupAfterCompletion(@NonNull
                                        SynchronousTransactionState state,
                                        java.lang.Object transaction)
```
    Cleanup resources after transaction completion.
    Called after doCommit and doRollback execution, on any outcome. The default implementation does nothing.
    Should not throw any exceptions but just issue warnings on errors.
    
    Parameters:
    
    state - The state
    
    transaction - transaction object returned by doGetTransaction
  - doDestroyState
```
protected void doDestroyState(@NonNull
                              SynchronousTransactionState state)
```
    Destroy the state.
    
    Parameters:
    
    state - The state

Class AbstractSynchronousStateTransactionManager<T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

AbstractSynchronousStateTransactionManager

Method Detail

execute

executeRead

executeWrite

setTransactionSynchronization

getTransactionSynchronization

setDefaultTimeout

getDefaultTimeout

setNestedTransactionAllowed

isNestedTransactionAllowed

setValidateExistingTransaction

isValidateExistingTransaction

setGlobalRollbackOnParticipationFailure

isGlobalRollbackOnParticipationFailure

setFailEarlyOnGlobalRollbackOnly

isFailEarlyOnGlobalRollbackOnly

setRollbackOnCommitFailure

isRollbackOnCommitFailure

getTransaction

prepareTransactionStatus

newTransactionStatus

getConnection

prepareSynchronization

determineTimeout

suspend

resume

commit

rollback

triggerBeforeCommit

triggerBeforeCompletion

invokeAfterCompletion

doGetTransaction

isExistingTransaction

useSavepointForNestedTransaction

doBegin

doSuspend

doResume

shouldCommitOnGlobalRollbackOnly

prepareForCommit

doCommit

doRollback

doSetRollbackOnly

registerAfterCompletionWithExistingTransaction

doCleanupAfterCompletion

doDestroyState