# Uses of Class
org.springframework.transaction.TransactionException

Packages that use TransactionException
Package
Description
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.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.transaction

Subclasses of TransactionException in org.springframework.transaction
Modifier and Type
Class
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
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.reactive

Methods in org.springframework.transaction.reactive that throw TransactionException
Modifier and Type
Method
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
Description
`final 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`
CallbackPreferringPlatformTransactionManager.`execute(TransactionDefinition definition, TransactionCallback<T> callback)`
Execute the action specified by the given callback object within a 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)`
`default void`
TransactionOperations.`executeWithoutResult(Consumer<TransactionStatus> action)`
Execute the action specified by the given `Runnable` within a transaction.
`final 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 final void`
AbstractPlatformTransactionManager.`resume(Object transaction, AbstractPlatformTransactionManager.SuspendedResourcesHolder resourcesHolder)`
Resume the given transaction.
`final 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 final AbstractPlatformTransactionManager.SuspendedResourcesHolder`
AbstractPlatformTransactionManager.`suspend(Object transaction)`
Suspend the given transaction.