| 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.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. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected boolean | CciLocalTransactionManager. isRollbackOnly(Object transaction) | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | CannotCreateTransactionExceptionException thrown when a transaction can't be created using an
 underlying transaction API such as JTA. | 
| class  | HeuristicCompletionExceptionException that represents a transaction failure caused by a heuristic
 decision on the side of the transaction coordinator. | 
| class  | IllegalTransactionStateExceptionException thrown when the existence or non-existence of a transaction
 amounts to an illegal state according to the transaction propagation
 behavior that applies. | 
| class  | InvalidIsolationLevelExceptionException that gets thrown when an invalid isolation level is specified,
 i.e. | 
| class  | InvalidTimeoutExceptionException 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  | NestedTransactionNotSupportedExceptionException thrown when attempting to work with a nested transaction
 but nested transactions are not supported by the underlying backend. | 
| class  | NoTransactionExceptionException thrown when an operation is attempted that
 relies on an existing transaction (such as setting
 rollback status) and there is no existing transaction. | 
| class  | TransactionSuspensionNotSupportedExceptionException thrown when attempting to suspend an existing transaction
 but transaction suspension is not supported by the underlying backend. | 
| class  | TransactionSystemExceptionException thrown when a general transaction system error is encountered,
 like on commit or rollback. | 
| class  | TransactionTimedOutExceptionException to be thrown when a transaction has timed out. | 
| class  | TransactionUsageExceptionSuperclass for exceptions caused by inappropriate usage of
 a Spring transaction API. | 
| class  | UnexpectedRollbackExceptionThrown when an attempt to commit a transaction resulted
 in an unexpected rollback. | 
| Modifier and Type | Method and Description | 
|---|---|
| reactor.core.publisher.Mono<Void> | ReactiveTransactionManager. commit(ReactiveTransaction transaction)Commit the given transaction, with regard to its status. | 
| void | PlatformTransactionManager. commit(TransactionStatus status)Commit the given transaction, with regard to its status. | 
| Object | SavepointManager. createSavepoint()Create a new savepoint. | 
| reactor.core.publisher.Mono<ReactiveTransaction> | ReactiveTransactionManager. getReactiveTransaction(TransactionDefinition definition)Emit a currently active reactive transaction or create a new one, according to
 the specified propagation behavior. | 
| 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. | 
| reactor.core.publisher.Mono<Void> | ReactiveTransactionManager. rollback(ReactiveTransaction transaction)Perform a rollback of the given transaction. | 
| void | PlatformTransactionManager. rollback(TransactionStatus status)Perform a rollback of the given transaction. | 
| void | SavepointManager. rollbackToSavepoint(Object savepoint)Roll back to the given savepoint. | 
| Modifier and Type | Method and Description | 
|---|---|
| <T> T | WebSphereUowTransactionManager. execute(TransactionDefinition definition,
       TransactionCallback<T> callback) | 
| Modifier and Type | Method and Description | 
|---|---|
| reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. commit(ReactiveTransaction transaction)This implementation of commit handles participating in existing
 transactions and programmatic rollback requests. | 
| protected abstract reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. doBegin(TransactionSynchronizationManager synchronizationManager,
       Object transaction,
       TransactionDefinition definition)Begin a new transaction with semantics according to the given transaction
 definition. | 
| protected abstract reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. doCommit(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status)Perform an actual commit of the given transaction. | 
| protected abstract Object | AbstractReactiveTransactionManager. doGetTransaction(TransactionSynchronizationManager synchronizationManager)Return a transaction object for the current transaction state. | 
| protected reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. doResume(TransactionSynchronizationManager synchronizationManager,
        Object transaction,
        Object suspendedResources)Resume the resources of the current transaction. | 
| protected abstract reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. doRollback(TransactionSynchronizationManager synchronizationManager,
          GenericReactiveTransaction status)Perform an actual rollback of the given transaction. | 
| protected reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. doSetRollbackOnly(TransactionSynchronizationManager synchronizationManager,
                 GenericReactiveTransaction status)Set the given transaction rollback-only. | 
| protected reactor.core.publisher.Mono<Object> | AbstractReactiveTransactionManager. doSuspend(TransactionSynchronizationManager synchronizationManager,
         Object transaction)Suspend the resources of the current transaction. | 
| <T> reactor.core.publisher.Flux<T> | TransactionalOperator. execute(TransactionCallback<T> action)Execute the action specified by the given callback object within a transaction. | 
| reactor.core.publisher.Mono<ReactiveTransaction> | AbstractReactiveTransactionManager. getReactiveTransaction(TransactionDefinition definition)This implementation handles propagation behavior. | 
| protected boolean | AbstractReactiveTransactionManager. isExistingTransaction(Object transaction)Check if the given transaction object indicates an existing transaction
 (that is, a transaction which has already started). | 
| protected reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. registerAfterCompletionWithExistingTransaction(TransactionSynchronizationManager synchronizationManager,
                                              Object transaction,
                                              List<TransactionSynchronization> synchronizations)Register the given list of transaction synchronizations with the existing transaction. | 
| reactor.core.publisher.Mono<Void> | AbstractReactiveTransactionManager. rollback(ReactiveTransaction transaction)This implementation of rollback handles participating in existing transactions. | 
| 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  Runnablewithin 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. |