javax.sql.DataSource , adding awareness of
Spring-managed transactions. Similar to a transactional JNDI DataSource
as provided by a Jakarta EE server.
Data access code that should remain unaware of Spring's data access support
can work with this proxy to seamlessly participate in Spring-managed transactions.
Note that the transaction manager, for example DataSourceTransactionManager,
still needs to work with the underlying DataSource, not with this proxy.
Make sure that TransactionAwareDataSourceProxy is the outermost DataSource
of a chain of DataSource proxies/adapters. TransactionAwareDataSourceProxy
can delegate either directly to the target connection pool or to some
intermediary proxy/adapter like LazyConnectionDataSourceProxy or
UserCredentialsDataSourceAdapter.
Delegates to DataSourceUtils for automatically participating in
thread-bound transactions, for example managed by DataSourceTransactionManager.
getConnection calls and close calls on returned Connections
will behave properly within a transaction, i.e. always operate on the transactional
Connection. If not within a transaction, normal DataSource behavior applies.
This proxy allows data access code to work with the plain JDBC API and still participate in Spring-managed transactions, similar to JDBC code in a Jakarta EE/JTA environment. However, if possible, use Spring's DataSourceUtils, JdbcTemplate or JDBC operation objects to get transaction participation even without a proxy for the target DataSource, avoiding the need to define such a proxy in the first place.
As a further effect, using a transaction-aware DataSource will apply remaining transaction timeouts to all created JDBC (Prepared/Callable)Statement. This means that all operations performed through standard JDBC will automatically participate in Spring-managed transaction timeouts.
Note
This DataSource proxy needs to return wrapped Connections (which
implement the ConnectionProxy interface) in order to handle close calls
properly. Use Connection#unwrap to retrieve the native JDBC Connection.
javax.sql.DataSource#getConnection() , java.sql.Connection#close() , DataSourceUtils#doGetConnection, DataSourceUtils#applyTransactionTimeout, DataSourceUtils#doReleaseConnection
| Modifier and Type | Class and Description |
|---|---|
| private class | TransactionAwareDataSourceProxy.
Invocation handler that delegates close calls on JDBC Connections to DataSourceUtils for being aware of thread-bound transactions. |
| Modifier and Type | Field and Description |
|---|---|
| private boolean | |
| private boolean |
| Access | Constructor and Description |
|---|---|
| public | |
| public | TransactionAwareDataSourceProxy(DataSource
the target DataSource targetDataSource)Create a new TransactionAwareDataSourceProxy. |
| Modifier and Type | Method and Description |
|---|---|
| public Connection | Returns: a transactional Connection if any, a new one elseOverrides org. Implements javax. Delegates to DataSourceUtils for automatically participating in Spring-managed transactions. |
| protected Connection | Returns: the wrapped Connectionthe DataSource that the Connection came from targetDataSource)Wraps the given Connection with a proxy that delegates every method call to it
but delegates |
| public void | setLazyTransactionalConnections(boolean lazyTransactionalConnections)
Specify whether to obtain the transactional target Connection lazily on actual data access. |
| public void | setReobtainTransactionalConnections(boolean reobtainTransactionalConnections)
Specify whether to reobtain the target Connection for each operation performed within a transaction. |
| protected boolean | shouldObtainFixedConnection(DataSource
the target DataSource targetDataSource)Determine whether to obtain a fixed target Connection for the proxy or to reobtain the target Connection for each operation. |
| lazyTransactionalConnections | back to summary |
|---|---|
| private boolean lazyTransactionalConnections | |
| reobtainTransactionalConnections | back to summary |
|---|---|
| private boolean reobtainTransactionalConnections | |
| TransactionAwareDataSourceProxy | back to summary |
|---|---|
| public TransactionAwareDataSourceProxy() Create a new TransactionAwareDataSourceProxy.
| |
| TransactionAwareDataSourceProxy | back to summary |
|---|---|
| public TransactionAwareDataSourceProxy(DataSource targetDataSource) Create a new TransactionAwareDataSourceProxy.
| |
| getConnection | back to summary |
|---|---|
| public Connection getConnection() throws SQLException Overrides org. Implements javax. Delegates to DataSourceUtils for automatically participating in Spring-managed transactions. Throws the original SQLException, if any. The returned Connection handle implements the ConnectionProxy interface, allowing to retrieve the underlying target Connection.
| |
| getTransactionAwareConnectionProxy | back to summary |
|---|---|
| protected Connection getTransactionAwareConnectionProxy(DataSource targetDataSource) Wraps the given Connection with a proxy that delegates every method call to it
but delegates
| |
| setLazyTransactionalConnections | back to summary |
|---|---|
| public void setLazyTransactionalConnections(boolean lazyTransactionalConnections) Specify whether to obtain the transactional target Connection lazily on actual data access. The default is "true". Specify "false" to immediately obtain a target Connection when a transaction-aware Connection handle is retrieved.
| |
| setReobtainTransactionalConnections | back to summary |
|---|---|
| public void setReobtainTransactionalConnections(boolean reobtainTransactionalConnections) Specify whether to reobtain the target Connection for each operation performed within a transaction. The default is "false". Specify "true" to reobtain transactional Connections for every call on the Connection proxy; this is advisable on JBoss if you hold on to a Connection handle across transaction boundaries. The effect of this setting is similar to the "hibernate.connection.release_mode" value "after_statement". | |
| shouldObtainFixedConnection | back to summary |
|---|---|
| protected boolean shouldObtainFixedConnection(DataSource targetDataSource) Determine whether to obtain a fixed target Connection for the proxy or to reobtain the target Connection for each operation. The default implementation returns
| |
| Modifier and Type | Field and Description |
|---|---|
| private boolean | |
| private Connection | |
| private final DataSource |
| Access | Constructor and Description |
|---|---|
| public |
| Modifier and Type | Method and Description |
|---|---|
| public Object | invoke(Object
the proxy instance that the method was invoked on proxy, Method the method, Object[] Method instance corresponding to
the interface method invoked on the proxy instance. The declaring
class of the Method object will be the interface that
the method was declared in, which may be a superinterface of the
proxy interface that the proxy class inherits the method through.an array of objects containing the values of the
arguments passed in the method invocation on the proxy instance,
or args)null if interface method takes no arguments.
Arguments of primitive types are wrapped in instances of the
appropriate primitive wrapper class, such as
java.lang.Integer or java.lang.Boolean.Implements java. Processes a method invocation on a proxy instance and returns the result. |
| closed | back to summary |
|---|---|
| private boolean closed | |
| target | back to summary |
|---|---|
| private Connection target
| |
| targetDataSource | back to summary |
|---|---|
| private final DataSource targetDataSource | |
| TransactionAwareInvocationHandler | back to summary |
|---|---|
| public TransactionAwareInvocationHandler(DataSource targetDataSource) | |
| invoke | back to summary |
|---|---|
| public Object invoke(Object proxy, Method method, Object[] args) throws Throwable Implements java. Doc from java. Processes a method invocation on a proxy instance and returns the result. This method will be invoked on an invocation handler when a method is invoked on a proxy instance that it is associated with.
| |