org.springframework.transaction.support

Class AbstractTransactionStatus

java.lang.Object

org.springframework.transaction.support.AbstractTransactionStatus

All Implemented Interfaces:

java.io.Flushable, SavepointManager, TransactionStatus

Direct Known Subclasses:

DefaultTransactionStatus, SimpleTransactionStatus

public abstract class AbstractTransactionStatus
extends java.lang.Object
implements TransactionStatus

Abstract base implementation of the TransactionStatus interface.

Pre-implements the handling of local rollback-only and completed flags, and delegation to an underlying SavepointManager. Also offers the option of a holding a savepoint within the transaction.

Does not assume any specific internal transaction handling, such as an underlying transaction object, and no transaction synchronization mechanism.

Since:

1.2.3

Author:

Juergen Hoeller

See Also:

setRollbackOnly(), isRollbackOnly(), setCompleted(), isCompleted(), getSavepointManager(), SimpleTransactionStatus, DefaultTransactionStatus

Constructor Summary

Constructors

Constructor and Description
AbstractTransactionStatus()

Method Summary

Modifier and Type	Method and Description
void	createAndHoldSavepoint() Create a savepoint and hold it for the transaction.
java.lang.Object	createSavepoint() This implementation delegates to a SavepointManager for the underlying transaction, if possible.
void	flush() This implementations is empty, considering flush as a no-op.
protected java.lang.Object	getSavepoint() Get the savepoint for this transaction, if any.
protected SavepointManager	getSavepointManager() Return a SavepointManager for the underlying transaction, if possible.
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() Determine the rollback-only flag via checking both the local rollback-only flag of this TransactionStatus and the global rollback-only flag of the underlying transaction, if any.
void	releaseHeldSavepoint() Release the savepoint that is held for the transaction.
void	releaseSavepoint(java.lang.Object savepoint) This implementation delegates to a SavepointManager for the underlying transaction, if possible.
void	rollbackToHeldSavepoint() Roll back to the savepoint that is held for the transaction and release the savepoint right afterwards.
void	rollbackToSavepoint(java.lang.Object savepoint) This implementation delegates to a SavepointManager for the underlying transaction, if possible.
void	setCompleted() Mark this transaction as completed, that is, committed or rolled back.
void	setRollbackOnly() Set the transaction rollback-only.
protected void	setSavepoint(java.lang.Object savepoint) Set a savepoint for this transaction.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.springframework.transaction.TransactionStatus

isNewTransaction

Constructor Detail

AbstractTransactionStatus

public AbstractTransactionStatus()

Method Detail

setRollbackOnly

public void setRollbackOnly()

Description copied from interface: TransactionStatus

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.

This is mainly intended for transactions managed by TransactionTemplate or TransactionInterceptor, where the actual commit/rollback decision is made by the container.

Specified by:

setRollbackOnly in interface TransactionStatus

See Also:

TransactionCallback.doInTransaction(org.springframework.transaction.TransactionStatus), TransactionAttribute.rollbackOn(java.lang.Throwable)

isRollbackOnly

public boolean isRollbackOnly()

Determine the rollback-only flag via checking both the local rollback-only flag of this TransactionStatus and the global rollback-only flag of the underlying transaction, if any.

Specified by:

isRollbackOnly in interface TransactionStatus

See Also:

isLocalRollbackOnly(), isGlobalRollbackOnly()

isLocalRollbackOnly

public boolean isLocalRollbackOnly()

Determine the rollback-only flag via checking this TransactionStatus.

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

isGlobalRollbackOnly

public boolean isGlobalRollbackOnly()

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

This implementation always returns false.

flush

public void flush()

This implementations is empty, considering flush as a no-op.

Specified by:

flush in interface java.io.Flushable

Specified by:

flush in interface TransactionStatus

setCompleted

public void setCompleted()

Mark this transaction as completed, that is, committed or rolled back.

isCompleted

public boolean isCompleted()

Description copied from interface: TransactionStatus

Return whether this transaction is completed, that is, whether it has already been committed or rolled back.

Specified by:

isCompleted in interface TransactionStatus

See Also:

PlatformTransactionManager.commit(org.springframework.transaction.TransactionStatus), PlatformTransactionManager.rollback(org.springframework.transaction.TransactionStatus)

setSavepoint

protected void setSavepoint(@Nullable
                            java.lang.Object savepoint)

Set a savepoint for this transaction. Useful for PROPAGATION_NESTED.

See Also:

TransactionDefinition.PROPAGATION_NESTED

getSavepoint

@Nullable
protected java.lang.Object getSavepoint()

Get the savepoint for this transaction, if any.

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 TransactionStatus.isNewTransaction(). For programmatic handling of custom savepoints, use SavepointManager's operations.

Specified by:

hasSavepoint in interface TransactionStatus

See Also:

TransactionStatus.isNewTransaction(), SavepointManager.createSavepoint(), SavepointManager.rollbackToSavepoint(Object), SavepointManager.releaseSavepoint(Object)

createAndHoldSavepoint

public void createAndHoldSavepoint()
                            throws TransactionException

Create a savepoint and hold it for the transaction.

Throws:

NestedTransactionNotSupportedException - if the underlying transaction does not support savepoints

TransactionException

rollbackToHeldSavepoint

public void rollbackToHeldSavepoint()
                             throws TransactionException

Roll back to the savepoint that is held for the transaction and release the savepoint right afterwards.

Throws:

TransactionException

releaseHeldSavepoint

public void releaseHeldSavepoint()
                          throws TransactionException

Release the savepoint that is held for the transaction.

Throws:

TransactionException

createSavepoint

public java.lang.Object createSavepoint()
                                 throws TransactionException

This implementation delegates to a SavepointManager for the underlying transaction, if possible.

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:

getSavepointManager(), SavepointManager.createSavepoint()

rollbackToSavepoint

public void rollbackToSavepoint(java.lang.Object savepoint)
                         throws TransactionException

This implementation delegates to a SavepointManager for the underlying transaction, if possible.

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:

getSavepointManager(), SavepointManager.rollbackToSavepoint(Object)

releaseSavepoint

public void releaseSavepoint(java.lang.Object savepoint)
                      throws TransactionException

This implementation delegates to a SavepointManager for the underlying transaction, if possible.

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:

getSavepointManager(), SavepointManager.releaseSavepoint(Object)

getSavepointManager

protected SavepointManager getSavepointManager()

Return a SavepointManager for the underlying transaction, if possible.

Default implementation always throws a NestedTransactionNotSupportedException.

Throws:

NestedTransactionNotSupportedException - if the underlying transaction does not support savepoints