Spring Framework

org.springframework.transaction.support
Class AbstractTransactionStatus

java.lang.Object
  extended by org.springframework.transaction.support.AbstractTransactionStatus
All Implemented Interfaces:
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
AbstractTransactionStatus()
           
 
Method Summary
 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.
 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 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(java.lang.Object savepoint)
Set a savepoint for this transaction. Useful for PROPAGATION_NESTED.

See Also:
TransactionDefinition.PROPAGATION_NESTED

getSavepoint

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.

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 rollbackToSavepoint or releaseSavepoint
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

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
TransactionException - if the rollback failed
See Also:
getSavepointManager(), SavepointManager

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

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

Spring Framework