Package io.micronaut.transaction.impl

Class AbstractInternalTransaction<C>

java.lang.Object

io.micronaut.transaction.impl.AbstractInternalTransaction<C>

Type Parameters:

C - The connection type

All Implemented Interfaces:

InternalTransaction<C>, SavepointManager, TransactionExecution, TransactionStatus<C>, Flushable

Direct Known Subclasses:

DefaultTransactionStatus

public abstract class AbstractInternalTransaction<C>
extends Object
implements InternalTransaction<C>

The abstract internal transaction.

Since:

4.0.0

Author:

Denis Stepanov

Constructor Summary

Constructors

Constructor	Description
AbstractInternalTransaction()

Method Summary

Modifier and Type	Method	Description
void	cleanupAfterCompletion()
Object	createSavepoint()	Create a new savepoint.
void	flush()	Flush the underlying session to the datastore, if applicable: for example, all affected Hibernate/JPA sessions.
boolean	hasSavepoint()	Return whether this transaction internally carries a savepoint, that is, has been created as nested transaction based on a savepoint.
boolean	isCompleted()	Return whether this transaction is completed, that is, whether it has already been committed or rolled back.
boolean	isGlobalRollbackOnly()	Template method for determining the global rollback-only flag of the underlying transaction, if any.
boolean	isLocalRollbackOnly()	Determine the rollback-only flag via checking this TransactionStatus.
boolean	isRollbackOnly()	Return whether the transaction has been marked as rollback-only (either by the application or by the transaction infrastructure).
void	registerSynchronization(@NonNull TransactionSynchronization synchronization)	Register a new transaction synchronization for the current state.
void	releaseHeldSavepoint()
void	releaseSavepoint(Object savepoint)	Explicitly release the given savepoint.
void	rollbackToSavepoint(Object savepoint)	Roll back to the given savepoint.
protected void	setGlobalRollbackOnly()	Set global rollback only.
void	setRollbackOnly()	Set the transaction rollback-only.
void	triggerAfterCommit()
void	triggerAfterCompletion(TransactionSynchronization.Status status)
void	triggerBeforeCommit()
void	triggerBeforeCompletion()

Methods inherited from class java.lang.Object

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

Methods inherited from interface io.micronaut.transaction.impl.InternalTransaction

resume, suspend

Methods inherited from interface io.micronaut.transaction.TransactionExecution

getTransactionDefinition, isNewTransaction

Methods inherited from interface io.micronaut.transaction.TransactionStatus

getConnection, getConnectionStatus, getTransaction

Constructor Details

AbstractInternalTransaction

public AbstractInternalTransaction()

Method Details

setGlobalRollbackOnly

protected void setGlobalRollbackOnly()

Set global rollback only.

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()

Description copied from interface: TransactionExecution

Return whether the transaction has been marked as rollback-only (either by the application or by the transaction infrastructure).

Specified by:

isRollbackOnly in interface TransactionExecution

Returns:

Whether the execution has been marked to rollback

isLocalRollbackOnly

public boolean isLocalRollbackOnly()

Description copied from interface: InternalTransaction

Determine the rollback-only flag via checking this TransactionStatus.

Will only return "true" if the application called setRollbackOnly on this TransactionStatus object.

Specified by:

isLocalRollbackOnly in interface InternalTransaction<C>

Returns:

Whether is local rollback

isGlobalRollbackOnly

public boolean isGlobalRollbackOnly()

Description copied from interface: InternalTransaction

Template method for determining the global rollback-only flag of the underlying transaction, if any.

This implementation always returns false.

Specified by:

isGlobalRollbackOnly in interface InternalTransaction<C>

Returns:

Whether is global rollback

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

Returns:

Whether the execution has completed

hasSavepoint

public boolean hasSavepoint()

Description copied from interface: TransactionStatus

Return whether this transaction internally carries a savepoint, that is, has been created as nested transaction based on a savepoint.

This method is mainly here for diagnostic purposes, alongside TransactionExecution.isNewTransaction(). For programmatic handling of custom savepoints, use the operations provided by SavepointManager.

Specified by:

hasSavepoint in interface TransactionStatus<C>

Returns:

Whether a save point is present

See Also:

• TransactionExecution.isNewTransaction()
• SavepointManager.createSavepoint()
• SavepointManager.rollbackToSavepoint(Object)
• SavepointManager.releaseSavepoint(Object)

releaseHeldSavepoint

public void releaseHeldSavepoint()
                          throws TransactionException

Specified by:

releaseHeldSavepoint in interface InternalTransaction<C>

Throws:

TransactionException

createSavepoint

public Object createSavepoint()
                       throws TransactionException

Description copied from interface: SavepointManager

Create a new savepoint. You can roll back to a specific savepoint via rollbackToSavepoint, and explicitly release a savepoint that you don't need anymore via releaseSavepoint.

Note that most transaction managers will automatically release savepoints at transaction completion.

Specified by:

createSavepoint in interface SavepointManager

Returns:

a savepoint object, to be passed into SavepointManager.rollbackToSavepoint(java.lang.Object) or SavepointManager.releaseSavepoint(java.lang.Object)

Throws:

NestedTransactionNotSupportedException - if the underlying transaction does not support savepoints

TransactionException - if the savepoint could not be created, for example because the transaction is not in an appropriate state

See Also:

• Connection.setSavepoint()

rollbackToSavepoint

public void rollbackToSavepoint(Object savepoint)
                         throws TransactionException

Description copied from interface: SavepointManager

Roll back to the given savepoint.

The savepoint will not be automatically released afterwards. You may explicitly call SavepointManager.releaseSavepoint(Object) or rely on automatic release on transaction completion.

Specified by:

rollbackToSavepoint in interface SavepointManager

Parameters:

savepoint - the savepoint to roll back to

Throws:

NestedTransactionNotSupportedException - if the underlying transaction does not support savepoints

TransactionException - if the rollback failed

See Also:

• Connection.rollback(java.sql.Savepoint)

releaseSavepoint

public void releaseSavepoint(Object savepoint)
                      throws TransactionException

Description copied from interface: SavepointManager

Explicitly release the given savepoint.

Note that most transaction managers will automatically release savepoints on transaction completion.

Implementations should fail as silently as possible if proper resource cleanup will eventually happen at transaction completion.

Specified by:

releaseSavepoint in interface SavepointManager

Parameters:

savepoint - the savepoint to release

Throws:

NestedTransactionNotSupportedException - if the underlying transaction does not support savepoints

TransactionException - if the release failed

See Also:

• Connection.releaseSavepoint(java.sql.Savepoint)

triggerBeforeCommit

public void triggerBeforeCommit()

Specified by:

triggerBeforeCommit in interface InternalTransaction<C>

triggerAfterCommit

public void triggerAfterCommit()

Specified by:

triggerAfterCommit in interface InternalTransaction<C>

triggerBeforeCompletion

public void triggerBeforeCompletion()

Specified by:

triggerBeforeCompletion in interface InternalTransaction<C>

triggerAfterCompletion

public void triggerAfterCompletion(TransactionSynchronization.Status status)

Specified by:

triggerAfterCompletion in interface InternalTransaction<C>

cleanupAfterCompletion

public void cleanupAfterCompletion()

Specified by:

cleanupAfterCompletion in interface InternalTransaction<C>

flush

public void flush()

Description copied from interface: TransactionStatus

Flush the underlying session to the datastore, if applicable: for example, all affected Hibernate/JPA sessions.

This is effectively just a hint and may be a no-op if the underlying transaction manager does not have a flush concept. A flush signal may get applied to the primary resource or to transaction synchronizations, depending on the underlying resource.

Specified by:

flush in interface Flushable

Specified by:

flush in interface TransactionStatus<C>

registerSynchronization

public void registerSynchronization(@NonNull
 @NonNull TransactionSynchronization synchronization)

Description copied from interface: TransactionStatus

Register a new transaction synchronization for the current state.

Note that synchronizations can implement the Ordered interface. They will be executed in an order according to their order value (if any).

Specified by:

registerSynchronization in interface TransactionStatus<C>

Parameters:

synchronization - the synchronization object to register