All Classes and Interfaces
Class
Description
Abstract implementation of
TransactionAttributeSource that caches
attributes for methods and implements a fallback policy: 1.Abstract base implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities as well as ClassLoader
exposure for endpoint invocations.Abstract base class that implements Spring's standard transaction workflow,
serving as basis for concrete platform transaction managers like
JtaTransactionManager.Holder for suspended resources.
Abstract base class that implements Spring's standard reactive transaction workflow,
serving as basis for concrete platform transaction managers.
Holder for suspended resources.
Abstract base
@Configuration class providing common structure for enabling
Spring's annotation-driven transaction management capability.Abstract base implementation of the
TransactionStatus interface.Implementation of the
TransactionAttributeSource
interface for working with transaction metadata in JDK 1.5+ annotation format.Advisor driven by a
TransactionAttributeSource, used to include
a transaction advice bean for methods that are transactional.Extension of the
PlatformTransactionManager
interface, exposing a method for executing a given callback within a transaction.Exception thrown on failure to acquire a lock during an update,
for example during a "select for update" statement.
Exception thrown when a transaction can't be created using an
underlying transaction API such as JTA.
Deprecated.
Implementation of
PersistenceExceptionTranslator that supports chaining,
allowing the addition of PersistenceExceptionTranslator instances in order.Deprecated.
as of 6.0.3 since it is not in use within core JDBC/ORM support
Composite
TransactionAttributeSource implementation that iterates
over a given array of TransactionAttributeSource instances.Exception thrown on various data access concurrency failures.
Common configuration interface for transaction manager implementations.
Generic base class for DAOs, defining template methods for DAO initialization.
Root of the hierarchy of data access exceptions discussed in
Expert One-On-One J2EE Design and Development.
Data access exception thrown when a resource fails completely:
for example, if we can't connect to a database using JDBC.
Miscellaneous utility methods for DAO implementations.
Exception thrown when an attempt to insert or update data
results in violation of an integrity constraint.
Exception thrown if certain expected data could not be retrieved, e.g.
Deprecated.
as of 6.0.3, in favor of
PessimisticLockingFailureException/CannotAcquireLockExceptionSpring's common transaction attribute implementation.
Default implementation of the
TransactionDefinition interface,
offering bean-style configuration and sensible default values
(PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false).Default implementation of the
TransactionStatus
interface, used by AbstractPlatformTransactionManager.TransactionAttribute implementation that delegates all calls to a given target
TransactionAttribute instance.TransactionDefinition implementation that delegates all calls to a given target
TransactionDefinition instance.Exception thrown when an attempt to insert or update data
results in violation of a primary key or unique constraint.
Strategy implementation for parsing EJB3's
TransactionAttribute annotation.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.
Enables Spring's annotation-driven transaction management capability, similar to
the support found in Spring's
<tx:*> XML namespace.Generic implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities for any kind of message
listener object (e.g.Internal exception thrown when a ResourceException has been encountered
during the endpoint invocation.
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.
Default implementation of the
ReactiveTransaction interface,
used by AbstractReactiveTransactionManager.Exception that represents a transaction failure caused by a heuristic
decision on the side of the transaction coordinator.
Exception thrown when the existence or non-existence of a transaction
amounts to an illegal state according to the transaction propagation
behavior that applies.
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.
Data access exception thrown when something unintended appears to have
happened with an update, but the transaction hasn't already been rolled back.
Exception thrown on incorrect usage of the API, such as failing to
"compile" a query object that needed compilation before execution.
Root for exceptions thrown when we use a data access resource incorrectly.
Exception that gets thrown when an invalid isolation level is specified,
i.e.
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.
Enumeration that represents transaction isolation levels for use with the
@Transactional annotation, corresponding to the
TransactionDefinition interface.Adapter for a JTA Synchronization, invoking the
afterCommit /
afterCompletion callbacks of Spring TransactionSynchronization
objects callbacks after the outer JTA transaction has completed.Strategy implementation for parsing JTA 1.2's
Transactional annotation.PlatformTransactionManager implementation
for JTA, delegating to a backend JTA provider.Parser for the <tx:jta-transaction-manager/> XML configuration element.
Deprecated.
as of 6.0, in favor of a straight
JtaTransactionManager definitionJTA transaction object, representing a
UserTransaction.FactoryBean that creates
a local JCA connection factory in "non-managed" mode (as defined by the
Java Connector Architecture specification).Adapter for a managed JTA Transaction handle, taking a JTA
TransactionManager reference and creating
a JTA Transaction handle for it.Very simple implementation of TransactionAttributeSource which will always return
the same TransactionAttribute for all methods fed to it.
Simple
TransactionAttributeSource implementation that
allows attributes to be stored per method in a Map.Simple
TransactionAttributeSource implementation that
allows attributes to be matched by registered name.Exception thrown when attempting to work with a nested transaction
but nested transactions are not supported by the underlying backend.
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.
Data access exception thrown when a resource fails completely and the failure is permanent.
Tag subclass of
RollbackRuleAttribute that has the opposite behavior
to the RollbackRuleAttribute superclass.Exception thrown when an operation is attempted that
relies on an existing transaction (such as setting
rollback status) and there is no existing transaction.
Exception thrown on an optimistic locking violation.
Exception thrown when the underlying resource denied a permission
to access a specific element, such as a specific database table.
Spring AOP exception translation aspect for use at Repository or DAO layer level.
AOP Alliance MethodInterceptor that provides persistence exception translation
based on a given PersistenceExceptionTranslator.
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).Interface implemented by Spring integrations with data access technologies
that throw runtime exceptions, such as JPA and Hibernate.
Exception thrown on a pessimistic locking violation.
This is the central interface in Spring's imperative transaction infrastructure.
Enumeration that represents transaction propagation behaviors for use
with the
Transactional annotation, corresponding to the
TransactionDefinition interface.@Configuration class that registers the Spring infrastructure beans
necessary to enable proxy-based annotation-driven transaction management.Exception to be thrown on a query timeout.
TransactionSynchronization implementation that manages a
resource object bound through TransactionSynchronizationManager.Representation of an ongoing
ReactiveTransactionManager transaction.This is the central interface in Spring's reactive transaction infrastructure.
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.
FactoryBean that bootstraps
the specified JCA 1.7 ResourceAdapter,
starting it with a local BootstrapContext
and exposing it for bean references.Generic interface to be implemented by resource holders.
Convenient base class for resource holders.
TransactionSynchronization implementation that manages a
ResourceHolder bound through TransactionSynchronizationManager.Extended variant of
TransactionDefinition, indicating a resource transaction
and in particular whether the transactional resource is ready for local optimizations.Extension of the
PlatformTransactionManager
interface, indicating a native resource transaction manager, operating on a single
target resource.Extension of
TransactionalEventListenerFactory,
detecting invalid transaction configuration for transactional event listeners:
Transactional only supported with Propagation.REQUIRES_NEW
and Propagation.NOT_SUPPORTED.Rule determining whether a given exception should cause a rollback.
TransactionAttribute implementation that works out whether a given exception
should cause transaction rollback by applying a number of rollback rules,
both positive and negative.
Interface that specifies an API to programmatically manage transaction
savepoints in a generic fashion.
Simple implementation of the JCA 1.7
BootstrapContext
interface, used for bootstrapping a JCA ResourceAdapter in a local environment.Default implementation of the
TransactionFactory strategy interface,
simply wrapping a standard JTA TransactionManager.A simple transaction-backed
Scope implementation, delegating to
TransactionSynchronizationManager's resource binding mechanism.A simple
TransactionStatus
implementation.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.
Adapter that implements the JTA
Synchronization
interface delegating to an underlying Spring
TransactionSynchronization.Strategy implementation for parsing Spring's
Transactional annotation.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.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.GenericApplicationListener adapter that delegates the processing of
an event to a TransactionalEventListener annotated method.An
EventListener that is invoked according to a TransactionPhase.EventListenerFactory implementation that handles TransactionalEventListener
annotated methods.A delegate for publishing transactional events in a reactive setup.
Operator class that simplifies programmatic transaction demarcation and
transaction exception handling.
A marker interface for manually created transactional proxies.
Strategy interface for parsing known transaction annotation types.
Base class for transactional aspects, such as the
TransactionInterceptor
or an AspectJ aspect.Coroutines-supporting extension of the callback interface.
Simple callback interface for proceeding with the target invocation.
Opaque object used to hold transaction information.
This interface adds a
rollbackOn specification to TransactionDefinition.PropertyEditor for
TransactionAttribute objects.Strategy interface used by
TransactionInterceptor for metadata retrieval.Advisor driven by a
TransactionAttributeSource, used to include
a TransactionInterceptor only for methods that are transactional.Property editor that converts a String into a
TransactionAttributeSource.Callback interface for reactive transactional code.
Callback interface for transactional code.
Simple convenience class for TransactionCallback implementation.
Mutable transaction context that encapsulates transactional synchronizations and
resources in the scope of a single transaction.
Delegate to register and obtain transactional contexts.
Interface that defines Spring-compliant transaction properties.
Superclass for all transaction exceptions.
Common representation of the current state of a transaction.
Callback interface for stateless listening to transaction creation/completion steps
in a transaction manager.
Strategy interface for creating JTA
Transaction
objects based on specified transactional characteristics.AOP Alliance MethodInterceptor for declarative transaction
management using the common Spring transaction infrastructure
(
PlatformTransactionManager/
ReactiveTransactionManager).Selects which implementation of
AbstractTransactionManagementConfiguration
should be used based on the value of EnableTransactionManagement.mode() on the
importing @Configuration class.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.Configuration constants for internal sharing across subpackages.
Marker interface for Spring transaction manager implementations,
either traditional or reactive.
Interface specifying basic transaction execution operations.
The phase in which a transactional event listener applies.
Proxy factory bean for simplified declarative transaction handling.
Representation of an ongoing
PlatformTransactionManager transaction.Exception thrown when attempting to suspend an existing transaction
but transaction suspension is not supported by the underlying backend.
Interface for reactive transaction synchronization callbacks.
Interface for transaction synchronization callbacks.
Deprecated.
as of 5.3, in favor of the default methods on the
TransactionSynchronization interfaceCentral delegate that manages resources and transaction synchronizations per
subscriber context.
Central delegate that manages resources and transaction synchronizations per thread.
Utility methods for triggering specific
TransactionSynchronization
callback methods on all currently registered synchronizations.Exception thrown when a general transaction system error is encountered,
like on commit or rollback.
Template class that simplifies programmatic transaction demarcation and
transaction exception handling.
Exception to be thrown when a transaction has timed out.
Superclass for exceptions caused by inappropriate usage of
a Spring transaction API.
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.
Data access exception thrown when a resource fails temporarily
and the operation can be retried.
NamespaceHandler allowing for the configuration of
declarative transaction management using either XML or using annotations.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.
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.
Thrown when an attempt to commit a transaction resulted
in an unexpected rollback.
Adapter for a JTA UserTransaction handle, taking a JTA
TransactionManager reference and creating
a JTA UserTransaction handle for it.
PessimisticLockingFailureException/CannotAcquireLockException