|
| |
|
| java.lang.Object
 org.springframework.transaction.support.TransactionSynchronizationManager
| TransactionSynchronizationManager | | abstract public class TransactionSynchronizationManager (Code) | | Central helper that manages resources and transaction synchronizations per thread.
To be used by resource management code but not by typical application code.
Supports one resource per key without overwriting, that is, a resource needs
to be removed before a new one can be set for the same key.
Supports a list of transaction synchronizations if synchronization is active.
Resource management code should check for thread-bound resources, e.g. JDBC
Connections or Hibernate Sessions, via getResource. Such code is
normally not supposed to bind resources to threads, as this is the responsibility
of transaction managers. A further option is to lazily bind on first use if
transaction synchronization is active, for performing transactions that span
an arbitrary number of resources.
Transaction synchronization must be activated and deactivated by a transaction
manager via
TransactionSynchronizationManager.initSynchronization() and
TransactionSynchronizationManager.clearSynchronization() .
This is automatically supported by
AbstractPlatformTransactionManager ,
and thus by all standard Spring transaction managers, such as
org.springframework.transaction.jta.JtaTransactionManager and
org.springframework.jdbc.datasource.DataSourceTransactionManager .
Resource management code should only register synchronizations when this
manager is active, which can be checked via
TransactionSynchronizationManager.isSynchronizationActive ;
it should perform immediate resource cleanup else. If transaction synchronization
isn't active, there is either no current transaction, or the transaction manager
doesn't support transaction synchronization.
Synchronization is for example used to always return the same resources
within a JTA transaction, e.g. a JDBC Connection or a Hibernate Session for
any given DataSource or SessionFactory, respectively.
author:
Juergen Hoeller
since:
02.06.2003
See Also: TransactionSynchronizationManager.isSynchronizationActive
See Also: TransactionSynchronizationManager.registerSynchronization
See Also: TransactionSynchronization
See Also: AbstractPlatformTransactionManager.setTransactionSynchronization
See Also: org.springframework.transaction.jta.JtaTransactionManager
See Also: org.springframework.jdbc.datasource.DataSourceTransactionManager
See Also: org.springframework.jdbc.datasource.DataSourceUtils.getConnection |
| Method Summary | |
| public static void | bindResource(Object key, Object value)
Bind the given resource for the given key to the current thread. | | public static void | clear()
Clear the entire transaction synchronization state for the current thread:
registered synchronizations as well as the various transaction characteristics. | | public static void | clearSynchronization()
Deactivate transaction synchronization for the current thread. | | public static Integer | getCurrentTransactionIsolationLevel()
Return the isolation level for the current transaction, if any. | | public static String | getCurrentTransactionName()
Return the name of the current transaction, or null if none set. | | public static Object | getResource(Object key)
Retrieve a resource for the given key that is bound to the current thread. | | public static Map | getResourceMap()
Return all resources that are bound to the current thread.
Mainly for debugging purposes. | | public static List | getSynchronizations()
Return an unmodifiable snapshot list of all registered synchronizations
for the current thread. | | public static boolean | hasResource(Object key)
Check if there is a resource for the given key bound to the current thread. | | public static void | initSynchronization()
Activate transaction synchronization for the current thread. | | public static boolean | isActualTransactionActive()
Return whether there currently is an actual transaction active. | | public static boolean | isCurrentTransactionReadOnly()
Return whether the current transaction is marked as read-only.
To be called by resource management code when preparing a newly
created resource (for example, a Hibernate Session).
Note that transaction synchronizations receive the read-only flag
as argument for the beforeCommit callback, to be able
to suppress change detection on commit. | | public static boolean | isSynchronizationActive()
Return if transaction synchronization is active for the current thread. | | public static void | registerSynchronization(TransactionSynchronization synchronization)
Register a new transaction synchronization for the current thread. | | public static void | setActualTransactionActive(boolean active)
Expose whether there currently is an actual transaction active. | | public static void | setCurrentTransactionIsolationLevel(Integer isolationLevel)
Expose an isolation level for the current transaction. | | public static void | setCurrentTransactionName(String name)
Expose the name of the current transaction, if any. | | public static void | setCurrentTransactionReadOnly(boolean readOnly)
Expose a read-only flag for the current transaction. | | public static Object | unbindResource(Object key)
Unbind a resource for the given key from the current thread. |
| clearSynchronization | | public static void clearSynchronization() throws IllegalStateException(Code) | | Deactivate transaction synchronization for the current thread.
Called by the transaction manager on transaction cleanup.
throws:
IllegalStateException - if synchronization is not active |
| getResource | | public static Object getResource(Object key)(Code) | | Retrieve a resource for the given key that is bound to the current thread.
Parameters:
key - the key to check (usually the resource factory) a value bound to the current thread (usually the activeresource object), or null if none
See Also: ResourceTransactionManager.getResourceFactory |
| getResourceMap | | public static Map getResourceMap()(Code) | | Return all resources that are bound to the current thread.
Mainly for debugging purposes. Resource managers should always invoke
hasResource for a specific resource key that they are interested in.
a Map with resource keys (usually the resource factory) and resourcevalues (usually the active resource object), or an empty Map if there arecurrently no resources bound
See Also: TransactionSynchronizationManager.hasResource |
| hasResource | | public static boolean hasResource(Object key)(Code) | | Check if there is a resource for the given key bound to the current thread.
Parameters:
key - the key to check (usually the resource factory) if there is a value bound to the current thread
See Also: ResourceTransactionManager.getResourceFactory
See Also: |
| initSynchronization | | public static void initSynchronization() throws IllegalStateException(Code) | | Activate transaction synchronization for the current thread.
Called by a transaction manager on transaction begin.
throws:
IllegalStateException - if synchronization is already active |
| isActualTransactionActive | | public static boolean isActualTransactionActive()(Code) | | Return whether there currently is an actual transaction active.
This indicates whether the current thread is associated with an actual
transaction rather than just with active transaction synchronization.
To be called by resource management code that wants to discriminate
between active transaction synchronization (with or without backing
resource transaction; also on PROPAGATION_SUPPORTS) and an actual
transaction being active (with backing resource transaction;
on PROPAGATION_REQUIRES, PROPAGATION_REQUIRES_NEW, etc).
See Also: TransactionSynchronizationManager.isSynchronizationActive() |
| isCurrentTransactionReadOnly | | public static boolean isCurrentTransactionReadOnly()(Code) | | Return whether the current transaction is marked as read-only.
To be called by resource management code when preparing a newly
created resource (for example, a Hibernate Session).
Note that transaction synchronizations receive the read-only flag
as argument for the beforeCommit callback, to be able
to suppress change detection on commit. The present method is meant
to be used for earlier read-only checks, for example to set the
flush mode of a Hibernate Session to "FlushMode.NEVER" upfront.
See Also: org.springframework.transaction.TransactionDefinition.isReadOnly
See Also: TransactionSynchronization.beforeCommit(boolean)
See Also: org.hibernate.Session.flush
See Also: org.hibernate.Session.setFlushMode
See Also: org.hibernate.FlushMode.NEVER |
| setActualTransactionActive | | public static void setActualTransactionActive(boolean active)(Code) | | Expose whether there currently is an actual transaction active.
Called by the transaction manager on transaction begin and on cleanup.
Parameters:
active - true to mark the current thread as being associatedwith an actual transaction; false to reset that marker |
| setCurrentTransactionReadOnly | | public static void setCurrentTransactionReadOnly(boolean readOnly)(Code) | | Expose a read-only flag for the current transaction.
Called by the transaction manager on transaction begin and on cleanup.
Parameters:
readOnly - true to mark the current transactionas read-only; false to reset such a read-only marker
See Also: org.springframework.transaction.TransactionDefinition.isReadOnly |
|
|
|