## Uses of Class
org.springframework.transaction.TransactionException

- Packages that use TransactionException
  Package | Description
  --- | ---
  org.springframework.jca.cci.connection | Provides a utility class for easy ConnectionFactory access, a PlatformTransactionManager for local CCI transactions, and various simple ConnectionFactory proxies/adapters.
  org.springframework.jdbc.datasource | Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
  org.springframework.orm.jpa | Package providing integration of JPA (Java Persistence API) with Spring concepts.
  org.springframework.orm.jpa.vendor | Support classes for adapting to specific JPA vendors.
  org.springframework.transaction | Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
  org.springframework.transaction.jta | Transaction SPI implementation for JTA.
  org.springframework.transaction.reactive | Support classes for reactive transaction management.
  org.springframework.transaction.support | Support classes for the org.springframework.transaction package.

- - ### Uses of TransactionException in org.springframework.jca.cci.connection

    Methods in org.springframework.jca.cci.connection that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `protected boolean` | CciLocalTransactionManager.`isRollbackOnly(Object transaction)` Deprecated.

  - ### Uses of TransactionException in org.springframework.jdbc.datasource

    Methods in org.springframework.jdbc.datasource that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | JdbcTransactionObjectSupport.`createSavepoint()` This implementation creates a JDBC 3.0 Savepoint and returns it.
    `protected ConnectionHolder` | JdbcTransactionObjectSupport.`getConnectionHolderForSavepoint()`
    `void` | JdbcTransactionObjectSupport.`releaseSavepoint(Object savepoint)` This implementation releases the given JDBC 3.0 Savepoint.
    `void` | JdbcTransactionObjectSupport.`rollbackToSavepoint(Object savepoint)` This implementation rolls back to the given JDBC 3.0 Savepoint.

  - ### Uses of TransactionException in org.springframework.orm.jpa

    Methods in org.springframework.orm.jpa that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | JpaDialect.`beginTransaction(EntityManager entityManager, TransactionDefinition definition)` Begin the given JPA transaction, applying the semantics specified by the given Spring transaction definition (in particular, an isolation level and a timeout).
    `Object` | DefaultJpaDialect.`beginTransaction(EntityManager entityManager, TransactionDefinition definition)` This implementation invokes the standard JPA `Transaction.begin` method.

  - ### Uses of TransactionException in org.springframework.orm.jpa.vendor

    Methods in org.springframework.orm.jpa.vendor that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | EclipseLinkJpaDialect.`beginTransaction(EntityManager entityManager, TransactionDefinition definition)`
    `Object` | HibernateJpaDialect.`beginTransaction(EntityManager entityManager, TransactionDefinition definition)`

  - ### Uses of TransactionException in org.springframework.transaction

    Subclasses of TransactionException in org.springframework.transaction
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CannotCreateTransactionException` Exception thrown when a transaction can't be created using an underlying transaction API such as JTA.
    `class` | `HeuristicCompletionException` Exception that represents a transaction failure caused by a heuristic decision on the side of the transaction coordinator.
    `class` | `IllegalTransactionStateException` Exception thrown when the existence or non-existence of a transaction amounts to an illegal state according to the transaction propagation behavior that applies.
    `class` | `InvalidIsolationLevelException` Exception that gets thrown when an invalid isolation level is specified, i.e.
    `class` | `InvalidTimeoutException` Exception that gets thrown when an invalid timeout is specified, that is, the specified timeout valid is out of range or the transaction manager implementation doesn't support timeouts.
    `class` | `NestedTransactionNotSupportedException` Exception thrown when attempting to work with a nested transaction but nested transactions are not supported by the underlying backend.
    `class` | `NoTransactionException` Exception thrown when an operation is attempted that relies on an existing transaction (such as setting rollback status) and there is no existing transaction.
    `class` | `TransactionSuspensionNotSupportedException` Exception thrown when attempting to suspend an existing transaction but transaction suspension is not supported by the underlying backend.
    `class` | `TransactionSystemException` Exception thrown when a general transaction system error is encountered, like on commit or rollback.
    `class` | `TransactionTimedOutException` Exception to be thrown when a transaction has timed out.
    `class` | `TransactionUsageException` Superclass for exceptions caused by inappropriate usage of a Spring transaction API.
    `class` | `UnexpectedRollbackException` Thrown when an attempt to commit a transaction resulted in an unexpected rollback.

    Methods in org.springframework.transaction that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `void` | PlatformTransactionManager.`commit(TransactionStatus status)` Commit the given transaction, with regard to its status.
    `Object` | SavepointManager.`createSavepoint()` Create a new savepoint.
    `TransactionStatus` | PlatformTransactionManager.`getTransaction(TransactionDefinition definition)` Return a currently active transaction or create a new one, according to the specified propagation behavior.
    `void` | SavepointManager.`releaseSavepoint(Object savepoint)` Explicitly release the given savepoint.
    `void` | PlatformTransactionManager.`rollback(TransactionStatus status)` Perform a rollback of the given transaction.
    `void` | SavepointManager.`rollbackToSavepoint(Object savepoint)` Roll back to the given savepoint.

  - ### Uses of TransactionException in org.springframework.transaction.jta

    Methods in org.springframework.transaction.jta that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `<T> T` | WebSphereUowTransactionManager.`execute(TransactionDefinition definition, TransactionCallback<T> callback)`

  - ### Uses of TransactionException in org.springframework.transaction.reactive

    Methods in org.springframework.transaction.reactive that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `<T> reactor.core.publisher.Flux<T>` | TransactionalOperator.`execute(TransactionCallback<T> action)` Execute the action specified by the given callback object within a transaction.

  - ### Uses of TransactionException in org.springframework.transaction.support

    Methods in org.springframework.transaction.support that throw TransactionException
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractPlatformTransactionManager.`commit(TransactionStatus status)` This implementation of commit handles participating in existing transactions and programmatic rollback requests.
    `void` | AbstractTransactionStatus.`createAndHoldSavepoint()` Create a savepoint and hold it for the transaction.
    `Object` | AbstractTransactionStatus.`createSavepoint()` This implementation delegates to a SavepointManager for the underlying transaction, if possible.
    `protected abstract void` | AbstractPlatformTransactionManager.`doBegin(Object transaction, TransactionDefinition definition)` Begin a new transaction with semantics according to the given transaction definition.
    `protected abstract void` | AbstractPlatformTransactionManager.`doCommit(DefaultTransactionStatus status)` Perform an actual commit of the given transaction.
    `protected abstract Object` | AbstractPlatformTransactionManager.`doGetTransaction()` Return a transaction object for the current transaction state.
    `protected void` | AbstractPlatformTransactionManager.`doResume(Object transaction, Object suspendedResources)` Resume the resources of the current transaction.
    `protected abstract void` | AbstractPlatformTransactionManager.`doRollback(DefaultTransactionStatus status)` Perform an actual rollback of the given transaction.
    `protected void` | AbstractPlatformTransactionManager.`doSetRollbackOnly(DefaultTransactionStatus status)` Set the given transaction rollback-only.
    `protected Object` | AbstractPlatformTransactionManager.`doSuspend(Object transaction)` Suspend the resources of the current transaction.
    `<T> T` | TransactionOperations.`execute(TransactionCallback<T> action)` Execute the action specified by the given callback object within a transaction.
    `<T> T` | TransactionTemplate.`execute(TransactionCallback<T> action)`
    `<T> T` | CallbackPreferringPlatformTransactionManager.`execute(TransactionDefinition definition, TransactionCallback<T> callback)` Execute the action specified by the given callback object within a transaction.
    `default void` | TransactionOperations.`executeWithoutResult(Consumer<TransactionStatus> action)` Execute the action specified by the given `Runnable` within a transaction.
    `TransactionStatus` | AbstractPlatformTransactionManager.`getTransaction(TransactionDefinition definition)` This implementation handles propagation behavior.
    `protected boolean` | AbstractPlatformTransactionManager.`isExistingTransaction(Object transaction)` Check if the given transaction object indicates an existing transaction (that is, a transaction which has already started).
    `protected void` | AbstractPlatformTransactionManager.`registerAfterCompletionWithExistingTransaction(Object transaction, List<TransactionSynchronization> synchronizations)` Register the given list of transaction synchronizations with the existing transaction.
    `void` | AbstractTransactionStatus.`releaseHeldSavepoint()` Release the savepoint that is held for the transaction.
    `void` | AbstractTransactionStatus.`releaseSavepoint(Object savepoint)` This implementation delegates to a SavepointManager for the underlying transaction, if possible.
    `protected void` | AbstractPlatformTransactionManager.`resume(Object transaction, AbstractPlatformTransactionManager.SuspendedResourcesHolder resourcesHolder)` Resume the given transaction.
    `void` | AbstractPlatformTransactionManager.`rollback(TransactionStatus status)` This implementation of rollback handles participating in existing transactions.
    `void` | AbstractTransactionStatus.`rollbackToHeldSavepoint()` Roll back to the savepoint that is held for the transaction and release the savepoint right afterwards.
    `void` | AbstractTransactionStatus.`rollbackToSavepoint(Object savepoint)` This implementation delegates to a SavepointManager for the underlying transaction, if possible.
    `protected AbstractPlatformTransactionManager.SuspendedResourcesHolder` | AbstractPlatformTransactionManager.`suspend(Object transaction)` Suspend the given transaction.