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
    Modifier and Type | Method and Description
    --- | ---
    `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