Java Doc for TopLinkTransactionManager.java in  » J2EE » spring-framework-2.5 » org » springframework » orm » toplink » Java Source Code / Java DocumentationJava Source Code and Java Documentation

This transaction manager is appropriate for applications that use a single TopLink SessionFactory for transactional data access. JTA (usually through org.springframework.transaction.jta.JtaTransactionManager ) is necessary for accessing multiple transactional resources within the same transaction. Note that you need to configure TopLink with an appropriate external transaction controller in order to make it participate in JTA transactions.

This transaction manager also supports direct DataSource access within a transaction (i.e. plain JDBC code working with the same DataSource), but only for transactions that are not marked as read-only. This allows for mixing services which access TopLink and services which use plain JDBC (without being aware of TopLink)! Application code needs to stick to the same simple Connection lookup pattern as with org.springframework.jdbc.datasource.DataSourceTransactionManager (i.e. org.springframework.jdbc.datasource.DataSourceUtils.getConnection or going through a org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy ).

Note: To be able to register a DataSource's Connection for plain JDBC code, this instance needs to be aware of the DataSource ( TopLinkTransactionManager.setDataSource ). The given DataSource should obviously match the one used by the given TopLink SessionFactory.

On JDBC 3.0, this transaction manager supports nested transactions via JDBC 3.0 Savepoints. The TopLinkTransactionManager.setNestedTransactionAllowed "nestedTransactionAllowed"} flag defaults to "false", though, as nested transactions will just apply to the JDBC Connection, not to the TopLink PersistenceManager and its cached objects. You can manually set the flag to "true" if you want to use nested transactions for JDBC access code which participates in TopLink transactions (provided that your JDBC driver supports Savepoints). Note that TopLink itself does not support nested transactions! Hence, do not expect TopLink access code to semantically participate in a nested transaction.

Thanks to Slavik Markovich for implementing the initial TopLink support prototype!
author:
   Juergen Hoeller
author:
   James Clark
since:
   1.2
See Also:   TopLinkTransactionManager.setSessionFactory
See Also:   TopLinkTransactionManager.setDataSource
See Also:   LocalSessionFactoryBean
See Also:   SessionFactoryUtils.getSession
See Also:   SessionFactoryUtils.releaseSession
See Also:   TopLinkTemplate
See Also:   oracle.toplink.sessions.Session.getActiveUnitOfWork
See Also:   org.springframework.jdbc.datasource.DataSourceUtils.getConnection
See Also:   org.springframework.jdbc.datasource.DataSourceUtils.applyTransactionTimeout
See Also:   org.springframework.jdbc.datasource.DataSourceUtils.releaseConnection
See Also:   org.springframework.jdbc.core.JdbcTemplate
See Also:   org.springframework.jdbc.datasource.DataSourceTransactionManager
See Also:   org.springframework.transaction.jta.JtaTransactionManager

A transactional JDBC Connection for this DataSource will be provided to application code accessing this DataSource directly via DataSourceUtils or JdbcTemplate.

Applied to any SQLException root cause of a TopLink DatabaseException that is thrown on commit.

By default, database transactions are started early.

Will automatically apply a specified SQLExceptionTranslator to a TopLink DatabaseException, else rely on TopLink's default translation.
Parameters:
  ex - TopLinkException that occured a corresponding DataAccessException
See Also:   SessionFactoryUtils.convertTopLinkAccessException
See Also:   TopLinkTransactionManager.setJdbcExceptionTranslator

Default implementation casts to oracle.toplink.publicinterface.Session and fetches the Connection from the DatabaseAccessor exposed there.
Parameters:
  session - the current TopLink Session the underlying JDBC Connection, or null if none found
See Also:   oracle.toplink.publicinterface.Session.getAccessor
See Also:   oracle.toplink.internal.databaseaccess.DatabaseAccessor.getConnection

A transactional JDBC Connection for this DataSource will be provided to application code accessing this DataSource directly via DataSourceUtils or JdbcTemplate. The Connection will be taken from the TopLink Session. This will only happen for transactions that are not marked as read-only. TopLink does not support database transactions for pure read-only operations on a Session (that is, without a UnitOfWork).

Note that you need to use a TopLink Session with a DatabaseAccessor to allow for exposing TopLink transactions as JDBC transactions. This is the case of all standard TopLink configurations.

The DataSource specified here should be the target DataSource to manage transactions for, not a TransactionAwareDataSourceProxy. Only data access code may work with TransactionAwareDataSourceProxy, while the transaction manager needs to work on the underlying target DataSource. If there's nevertheless a TransactionAwareDataSourceProxy passed in, it will be unwrapped to extract its target DataSource.
See Also:   org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy
See Also:   org.springframework.jdbc.datasource.DataSourceUtils
See Also:   org.springframework.jdbc.core.JdbcTemplate

Applied to any SQLException root cause of a TopLink DatabaseException that is thrown on commit. The default is to rely on TopLink's native exception translation.
Parameters:
  jdbcExceptionTranslator - the exception translator
See Also:   oracle.toplink.exceptions.DatabaseException
See Also:   org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator
See Also:   org.springframework.jdbc.support.SQLStateSQLExceptionTranslator
See Also:   TopLinkTransactionManager.setDataSource(javax.sql.DataSource)

By default, database transactions are started early. This allows for reusing the same JDBC Connection throughout an entire transaction, including read operations, and also for exposing TopLink transactions to JDBC access code (working on the same DataSource).

It is only recommended to switch this flag to "true" when no JDBC access code is involved in any of the transactions, and when it is acceptable to perform read operations outside of the transactional JDBC Connection.
See Also:   TopLinkTransactionManager.setDataSource(javax.sql.DataSource)
See Also:   oracle.toplink.sessions.UnitOfWork.beginEarlyTransaction

The passed-in SessionFactory will be asked for a plain Session in case of a read-only transaction (where no active UnitOfWork is supposed to be available), and for a managed Session else (with an active UnitOfWork that will be committed by this transaction manager).
See Also:   ServerSessionFactory
See Also:   SessionFactory.createSession
See Also:   SessionFactory.createManagedClientSession