org.springframework.transaction.support

## Class AbstractTransactionStatus

- java.lang.Object
- - org.springframework.transaction.support.AbstractTransactionStatus

All Implemented Interfaces:
  SavepointManager, TransactionStatus

Direct Known Subclasses:
  DefaultTransactionStatus, SimpleTransactionStatus

    public abstract class AbstractTransactionStatus
    extends 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

Methods
`void` `createAndHoldSavepoint()` Create a savepoint and hold it for the transaction.
`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 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(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(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(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(Object savepoint)

Set a savepoint for this transaction. Useful for PROPAGATION_NESTED.

See Also:
  `TransactionDefinition.PROPAGATION_NESTED`

#### getSavepoint

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