public interface PlatformTransactionManager
For implementors, it is recommended to derive from the provided
AbstractPlatformTransactionManager
class, which pre-implements the defined propagation behavior and takes care
of transaction synchronization handling. Subclasses have to implement
template methods for specific states of the underlying transaction,
for example: begin, suspend, resume, commit.
The default implementations of this strategy interface are
JtaTransactionManager
and
DataSourceTransactionManager
,
which can serve as an implementation guide for other transaction strategies.
TransactionTemplate
,
TransactionInterceptor
,
TransactionProxyFactoryBean
Modifier and Type | Method and Description |
---|---|
void |
commit(TransactionStatus status)
Commit the given transaction, with regard to its status.
|
TransactionStatus |
getTransaction(TransactionDefinition definition)
Return a currently active transaction or create a new one, according to
the specified propagation behavior.
|
void |
rollback(TransactionStatus status)
Perform a rollback of the given transaction.
|
TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException
Note that parameters like isolation level or timeout will only be applied to new transactions, and thus be ignored when participating in active ones.
Furthermore, not all transaction definition settings will be supported by every transaction manager: A proper transaction manager implementation should throw an exception when unsupported settings are encountered.
An exception to the above rule is the read-only flag, which should be ignored if no explicit read-only mode is supported. Essentially, the read-only flag is just a hint for potential optimization.
definition
- TransactionDefinition instance (can be null
for defaults),
describing propagation behavior, isolation level, timeout etc.TransactionException
- in case of lookup, creation, or system errorsIllegalTransactionStateException
- if the given transaction definition
cannot be executed (for example, if a currently active transaction is in
conflict with the specified propagation behavior)TransactionDefinition.getPropagationBehavior()
,
TransactionDefinition.getIsolationLevel()
,
TransactionDefinition.getTimeout()
,
TransactionDefinition.isReadOnly()
void commit(TransactionStatus status) throws TransactionException
If the transaction wasn't a new one, omit the commit for proper participation in the surrounding transaction. If a previous transaction has been suspended to be able to create a new one, resume the previous transaction after committing the new one.
Note that when the commit call completes, no matter if normally or throwing an exception, the transaction must be fully completed and cleaned up. No rollback call should be expected in such a case.
If this method throws an exception other than a TransactionException, then some before-commit error caused the commit attempt to fail. For example, an O/R Mapping tool might have tried to flush changes to the database right before commit, with the resulting DataAccessException causing the transaction to fail. The original exception will be propagated to the caller of this commit method in such a case.
status
- object returned by the getTransaction
methodUnexpectedRollbackException
- in case of an unexpected rollback
that the transaction coordinator initiatedHeuristicCompletionException
- in case of a transaction failure
caused by a heuristic decision on the side of the transaction coordinatorTransactionSystemException
- in case of commit or system errors
(typically caused by fundamental resource failures)IllegalTransactionStateException
- if the given transaction
is already completed (that is, committed or rolled back)TransactionException
TransactionStatus.setRollbackOnly()
void rollback(TransactionStatus status) throws TransactionException
If the transaction wasn't a new one, just set it rollback-only for proper participation in the surrounding transaction. If a previous transaction has been suspended to be able to create a new one, resume the previous transaction after rolling back the new one.
Do not call rollback on a transaction if commit threw an exception. The transaction will already have been completed and cleaned up when commit returns, even in case of a commit exception. Consequently, a rollback call after commit failure will lead to an IllegalTransactionStateException.
status
- object returned by the getTransaction
methodTransactionSystemException
- in case of rollback or system errors
(typically caused by fundamental resource failures)IllegalTransactionStateException
- if the given transaction
is already completed (that is, committed or rolled back)TransactionException