# All Classes and Interfaces

Class
Description
AbstractFallbackTransactionAttributeSource
Abstract implementation of `TransactionAttributeSource` that caches attributes for methods and implements a fallback policy: 1.
AbstractMessageEndpointFactory
Abstract base implementation of the JCA 1.7 `MessageEndpointFactory` interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations.
AbstractPlatformTransactionManager
Abstract base class that implements Spring's standard transaction workflow, serving as basis for concrete platform transaction managers like `JtaTransactionManager`.
AbstractPlatformTransactionManager.SuspendedResourcesHolder
Holder for suspended resources.
AbstractReactiveTransactionManager
Abstract base class that implements Spring's standard reactive transaction workflow, serving as basis for concrete platform transaction managers.
AbstractReactiveTransactionManager.SuspendedResourcesHolder
Holder for suspended resources.
AbstractTransactionManagementConfiguration
Abstract base `@Configuration` class providing common structure for enabling Spring's annotation-driven transaction management capability.
AbstractTransactionStatus
Abstract base implementation of the `TransactionStatus` interface.
AnnotationTransactionAttributeSource
Implementation of the `TransactionAttributeSource` interface for working with transaction metadata from annotations.
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by a `TransactionAttributeSource`, used to include a transaction advice bean for methods that are transactional.
CallbackPreferringPlatformTransactionManager
Extension of the `PlatformTransactionManager` interface, exposing a method for executing a given callback within a transaction.
CannotAcquireLockException
Exception thrown on failure to acquire a lock during an update, for example during a "select for update" statement.
CannotCreateTransactionException
Exception thrown when a transaction can't be created using an underlying transaction API such as JTA.
CannotSerializeTransactionException
Deprecated.
as of 6.0.3, in favor of `PessimisticLockingFailureException`/`CannotAcquireLockException`
ChainedPersistenceExceptionTranslator
Implementation of `PersistenceExceptionTranslator` that supports chaining, allowing the addition of PersistenceExceptionTranslator instances in order.
CleanupFailureDataAccessException
Deprecated.
as of 6.0.3 since it is not in use within core JDBC/ORM support
CompositeTransactionAttributeSource
Composite `TransactionAttributeSource` implementation that iterates over a given array of `TransactionAttributeSource` instances.
ConcurrencyFailureException
Exception thrown on various data access concurrency failures.
ConfigurableTransactionManager
Common configuration interface for transaction manager implementations.
DaoSupport
Generic base class for DAOs, defining template methods for DAO initialization.
DataAccessException
Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development.
DataAccessResourceFailureException
Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.
DataAccessUtils
Miscellaneous utility methods for DAO implementations.
DataIntegrityViolationException
Exception thrown when an attempt to execute an SQL statement fails to map the given data, typically but no limited to an insert or update data results in violation of an integrity constraint.
DataRetrievalFailureException
Exception thrown if certain expected data could not be retrieved, for example, when looking up specific data via a known identifier.
DeadlockLoserDataAccessException
Deprecated.
as of 6.0.3, in favor of `PessimisticLockingFailureException`/`CannotAcquireLockException`
DefaultTransactionAttribute
Spring's common transaction attribute implementation.
DefaultTransactionDefinition
Default implementation of the `TransactionDefinition` interface, offering bean-style configuration and sensible default values (PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false).
DefaultTransactionStatus
Default implementation of the `TransactionStatus` interface, used by `AbstractPlatformTransactionManager`.
DelegatingTransactionAttribute
`TransactionAttribute` implementation that delegates all calls to a given target `TransactionAttribute` instance.
DelegatingTransactionDefinition
`TransactionDefinition` implementation that delegates all calls to a given target `TransactionDefinition` instance.
DuplicateKeyException
Exception thrown when an attempt to insert or update data results in violation of a primary key or unique constraint.
Ejb3TransactionAnnotationParser
Strategy implementation for parsing EJB3's `TransactionAttribute` annotation.
EmptyResultDataAccessException
Data access exception thrown when a result was expected to have at least one row (or element) but zero rows (or elements) were actually returned.
EnableTransactionManagement
Enables Spring's annotation-driven transaction management capability, similar to the support found in Spring's `<tx:*>` XML namespace.
GenericMessageEndpointFactory
Generic implementation of the JCA 1.7 `MessageEndpointFactory` interface, providing transaction management capabilities for any kind of message listener object (for example, `jakarta.jms.MessageListener` objects or `MessageListener` objects).
GenericMessageEndpointFactory.InternalResourceException
Internal exception thrown when a ResourceException has been encountered during the endpoint invocation.
GenericMessageEndpointManager
Generic bean that manages JCA 1.7 message endpoints within a Spring application context, activating and deactivating the endpoint as part of the application context's lifecycle.
GenericReactiveTransaction
Default implementation of the `ReactiveTransaction` interface, used by `AbstractReactiveTransactionManager`.
HeuristicCompletionException
Exception that represents a transaction failure caused by a heuristic decision on the side of the transaction coordinator.
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.
IncorrectResultSizeDataAccessException
Data access exception thrown when a result was not of the expected size, for example when expecting a single row but getting 0 or more than 1 rows.
IncorrectUpdateSemanticsDataAccessException
Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back.
InvalidDataAccessApiUsageException
Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution.
InvalidDataAccessResourceUsageException
Root for exceptions thrown when we use a data access resource incorrectly.
InvalidIsolationLevelException
Exception that gets thrown when an invalid isolation level is specified, i.e.
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.
Isolation
Enumeration that represents transaction isolation levels for use with the `@Transactional` annotation, corresponding to the `TransactionDefinition` interface.
JtaAfterCompletionSynchronization
Adapter for a JTA Synchronization, invoking the `afterCommit` / `afterCompletion` callbacks of Spring `TransactionSynchronization` objects callbacks after the outer JTA transaction has completed.
JtaTransactionAnnotationParser
Strategy implementation for parsing JTA 1.2's `Transactional` annotation.
JtaTransactionManager
`PlatformTransactionManager` implementation for JTA, delegating to a backend JTA provider.
JtaTransactionManagerBeanDefinitionParser
Parser for the <tx:jta-transaction-manager/> XML configuration element.
JtaTransactionManagerFactoryBean
Deprecated.
as of 6.0, in favor of a straight `JtaTransactionManager` definition
JtaTransactionObject
JTA transaction object, representing a `UserTransaction`.
LocalConnectionFactoryBean
`FactoryBean` that creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).
ManagedTransactionAdapter
Adapter for a managed JTA Transaction handle, taking a JTA `TransactionManager` reference and creating a JTA `Transaction` handle for it.
MatchAlwaysTransactionAttributeSource
Very simple implementation of TransactionAttributeSource which will always return the same TransactionAttribute for all methods fed to it.
MethodMapTransactionAttributeSource
Simple `TransactionAttributeSource` implementation that allows attributes to be stored per method in a `Map`.
NameMatchTransactionAttributeSource
Simple `TransactionAttributeSource` implementation that allows attributes to be matched by registered name.
NestedTransactionNotSupportedException
Exception thrown when attempting to work with a nested transaction but nested transactions are not supported by the underlying backend.
NonTransientDataAccessException
Root of the hierarchy of data access exceptions that are considered non-transient - where a retry of the same operation would fail unless the cause of the Exception is corrected.
NonTransientDataAccessResourceException
Data access exception thrown when a resource fails completely and the failure is permanent.
NoRollbackRuleAttribute
Tag subclass of `RollbackRuleAttribute` that has the opposite behavior to the `RollbackRuleAttribute` superclass.
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.
OptimisticLockingFailureException
Exception thrown on an optimistic locking violation.
PermissionDeniedDataAccessException
Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table.
PersistenceExceptionTranslationAdvisor
Spring AOP exception translation aspect for use at Repository or DAO layer level.
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.
PersistenceExceptionTranslationPostProcessor
Bean post-processor that automatically applies persistence exception translation to any bean marked with Spring's @`Repository` annotation, adding a corresponding `PersistenceExceptionTranslationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).
PersistenceExceptionTranslator
Interface implemented by Spring integrations with data access technologies that throw runtime exceptions, such as JPA and Hibernate.
PessimisticLockingFailureException
Exception thrown on a pessimistic locking violation.
PlatformTransactionManager
This is the central interface in Spring's imperative transaction infrastructure.
Propagation
Enumeration that represents transaction propagation behaviors for use with the `Transactional` annotation, corresponding to the `TransactionDefinition` interface.
ProxyTransactionManagementConfiguration
`@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven transaction management.
QueryTimeoutException
Exception to be thrown on a query timeout.
ReactiveResourceSynchronization<O,K>
`TransactionSynchronization` implementation that manages a resource object bound through `TransactionSynchronizationManager`.
ReactiveTransaction
Representation of an ongoing `ReactiveTransactionManager` transaction.
ReactiveTransactionManager
This is the central interface in Spring's reactive transaction infrastructure.
RecoverableDataAccessException
Data access exception thrown when a previously failed operation might be able to succeed if the application performs some recovery steps and retries the entire transaction or in the case of a distributed transaction, the transaction branch.
ResourceAdapterFactoryBean
`FactoryBean` that bootstraps the specified JCA 1.7 `ResourceAdapter`, starting it with a local `BootstrapContext` and exposing it for bean references.
ResourceHolder
Generic interface to be implemented by resource holders.
ResourceHolderSupport
Convenient base class for resource holders.
ResourceHolderSynchronization<H extends ResourceHolder,K>
`TransactionSynchronization` implementation that manages a `ResourceHolder` bound through `TransactionSynchronizationManager`.
ResourceTransactionDefinition
Extended variant of `TransactionDefinition`, indicating a resource transaction and in particular whether the transactional resource is ready for local optimizations.
ResourceTransactionManager
Extension of the `PlatformTransactionManager` interface, indicating a native resource transaction manager, operating on a single target resource.
RestrictedTransactionalEventListenerFactory
Extension of `TransactionalEventListenerFactory`, detecting invalid transaction configuration for transactional event listeners: `Transactional` only supported with `Propagation.REQUIRES_NEW` and `Propagation.NOT_SUPPORTED`.
RollbackOn
An enum for global rollback-on behavior.
RollbackRuleAttribute
Rule determining whether a given exception should cause a rollback.
RuleBasedTransactionAttribute
TransactionAttribute implementation that works out whether a given exception should cause transaction rollback by applying a number of rollback rules, both positive and negative.
SavepointManager
Interface that specifies an API to programmatically manage transaction savepoints in a generic fashion.
SimpleBootstrapContext
Simple implementation of the JCA 1.7 `BootstrapContext` interface, used for bootstrapping a JCA ResourceAdapter in a local environment.
SimpleTransactionFactory
Default implementation of the `TransactionFactory` strategy interface, simply wrapping a standard JTA `TransactionManager`.
SimpleTransactionScope
A simple transaction-backed `Scope` implementation, delegating to `TransactionSynchronizationManager`'s resource binding mechanism.
SimpleTransactionStatus
A simple `TransactionStatus` implementation.
SmartTransactionObject
Interface to be implemented by transaction objects that are able to return an internal rollback-only marker, typically from another transaction that has participated and marked it as rollback-only.
SpringJtaSynchronizationAdapter
Adapter that implements the JTA `Synchronization` interface delegating to an underlying Spring `TransactionSynchronization`.
SpringTransactionAnnotationParser
Strategy implementation for parsing Spring's `Transactional` annotation.
Transactional
Describes a transaction attribute on an individual method or on a class.
TransactionalApplicationListener<E extends org.springframework.context.ApplicationEvent>
An `ApplicationListener` that is invoked according to a `TransactionPhase`.
TransactionalApplicationListener.SynchronizationCallback
Callback to be invoked on synchronization-driven event processing, wrapping the target listener invocation (`TransactionalApplicationListener.processEvent(E)`).
TransactionalApplicationListenerAdapter<E extends org.springframework.context.ApplicationEvent>
`TransactionalApplicationListener` adapter that delegates the processing of an event to a target `ApplicationListener` instance.
TransactionalApplicationListenerMethodAdapter
`GenericApplicationListener` adapter that delegates the processing of an event to a `TransactionalEventListener` annotated method.
TransactionalEventListener
An `EventListener` that is invoked according to a `TransactionPhase`.
TransactionalEventListenerFactory
`EventListenerFactory` implementation that handles `TransactionalEventListener` annotated methods.
TransactionalEventPublisher
A delegate for publishing transactional events in a reactive setup.
TransactionalOperator
Operator class that simplifies programmatic transaction demarcation and transaction exception handling.
TransactionalProxy
A marker interface for manually created transactional proxies.
TransactionAnnotationParser
Strategy interface for parsing known transaction annotation types.
TransactionAspectSupport
Base class for transactional aspects, such as the `TransactionInterceptor` or an AspectJ aspect.
TransactionAspectSupport.InvocationCallback
Simple callback interface for proceeding with the target invocation.
TransactionAspectSupport.TransactionInfo
Opaque object used to hold transaction information.
TransactionAttribute
This interface adds a `rollbackOn` specification to `TransactionDefinition`.
TransactionAttributeEditor
PropertyEditor for `TransactionAttribute` objects.
TransactionAttributeSource
Strategy interface used by `TransactionInterceptor` for metadata retrieval.
TransactionAttributeSourceAdvisor
Advisor driven by a `TransactionAttributeSource`, used to include a `TransactionInterceptor` only for methods that are transactional.
TransactionAttributeSourceEditor
Property editor that converts a String into a `TransactionAttributeSource`.
TransactionCallback<T>
Callback interface for reactive transactional code.
TransactionCallback<T>
Callback interface for transactional code.
TransactionCallbackWithoutResult
Simple convenience class for TransactionCallback implementation.
TransactionContext
Mutable transaction context that encapsulates transactional synchronizations and resources in the scope of a single transaction.
TransactionContextManager
Delegate to register and obtain transactional contexts.
TransactionDefinition
Interface that defines Spring-compliant transaction properties.
TransactionException
Superclass for all transaction exceptions.
TransactionExecution
Common representation of the current state of a transaction.
TransactionExecutionListener
Callback interface for stateless listening to transaction creation/completion steps in a transaction manager.
TransactionFactory
Strategy interface for creating JTA `Transaction` objects based on specified transactional characteristics.
TransactionInterceptor
AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (`PlatformTransactionManager`/ `ReactiveTransactionManager`).
TransactionManagementConfigurationSelector
Selects which implementation of `AbstractTransactionManagementConfiguration` should be used based on the value of `EnableTransactionManagement.mode()` on the importing `@Configuration` class.
TransactionManagementConfigurer
Interface to be implemented by @`Configuration` classes annotated with @`EnableTransactionManagement` that wish to (or need to) explicitly specify the default `PlatformTransactionManager` bean (or `ReactiveTransactionManager` bean) to be used for annotation-driven transaction management, as opposed to the default approach of a by-type lookup.
TransactionManagementConfigUtils
Configuration constants for internal sharing across subpackages.
TransactionManager
Marker interface for Spring transaction manager implementations, either traditional or reactive.
TransactionOperations
Interface specifying basic transaction execution operations.
TransactionPhase
The phase in which a transactional event listener applies.
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling.
TransactionStatus
Representation of an ongoing `PlatformTransactionManager` transaction.
TransactionSuspensionNotSupportedException
Exception thrown when attempting to suspend an existing transaction but transaction suspension is not supported by the underlying backend.
TransactionSynchronization
Interface for reactive transaction synchronization callbacks.
TransactionSynchronization
Interface for transaction synchronization callbacks.
TransactionSynchronizationAdapter
Deprecated.
as of 5.3, in favor of the default methods on the `TransactionSynchronization` interface
TransactionSynchronizationManager
Central delegate that manages resources and transaction synchronizations per subscriber context.
TransactionSynchronizationManager
Central delegate that manages resources and transaction synchronizations per thread.
TransactionSynchronizationUtils
Utility methods for triggering specific `TransactionSynchronization` callback methods on all currently registered synchronizations.
TransactionSystemException
Exception thrown when a general transaction system error is encountered, like on commit or rollback.
TransactionTemplate
Template class that simplifies programmatic transaction demarcation and transaction exception handling.
TransactionTimedOutException
Exception to be thrown when a transaction has timed out.
TransactionUsageException
Superclass for exceptions caused by inappropriate usage of a Spring transaction API.
TransientDataAccessException
Root of the hierarchy of data access exceptions that are considered transient - where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
TransientDataAccessResourceException
Data access exception thrown when a resource fails temporarily and the operation can be retried.
TxNamespaceHandler
`NamespaceHandler` allowing for the configuration of declarative transaction management using either XML or using annotations.
TypeMismatchDataAccessException
Exception thrown on mismatch between Java type and database type: for example on an attempt to set an object of the wrong type in an RDBMS column.
UncategorizedDataAccessException
Normal superclass when we can't distinguish anything more specific than "something went wrong with the underlying resource": for example, an SQLException from JDBC we can't pinpoint more precisely.
UnexpectedRollbackException
Thrown when an attempt to commit a transaction resulted in an unexpected rollback.
UserTransactionAdapter
Adapter for a JTA UserTransaction handle, taking a JTA `TransactionManager` reference and creating a JTA `UserTransaction` handle for it.