Java Doc for HibernateTransactionManager.java in  » J2EE » spring-framework-2.0.6 » org » springframework » orm » hibernate » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Supports custom isolation levels, and timeouts that get applied as appropriate Hibernate query timeouts. To support the latter, application code must either use HibernateTemplate (which by default applies the timeouts) or call SessionFactoryUtils.applyTransactionTimeout for each created Hibernate net.sf.hibernate.Query object.

This transaction manager is appropriate for applications that use a single Hibernate SessionFactory for transactional data access, but it also supports direct DataSource access within a transaction (i.e. plain JDBC code working with the same DataSource). This allows for mixing services which access Hibernate and services which use plain JDBC (without being aware of Hibernate)! 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 ( HibernateTransactionManager.setDataSource ). The given DataSource should obviously match the one used by the given SessionFactory. To achieve this, configure both to the same JNDI DataSource, or preferably create the SessionFactory with LocalSessionFactoryBean and a local DataSource (which will be autodetected by this transaction manager).

JTA (usually through org.springframework.transaction.jta.JtaTransactionManager ) is necessary for accessing multiple transactional resources within the same transaction. The DataSource that Hibernate uses needs to be JTA-enabled in such a scenario (see container setup). Normally, JTA setup for Hibernate is somewhat container-specific due to the JTA TransactionManager lookup, required for proper transactional handling of the SessionFactory-level read-write cache.

Fortunately, there is an easier way with Spring: SessionFactoryUtils (and thus HibernateTemplate ) registers synchronizations with Spring's org.springframework.transaction.support.TransactionSynchronizationManager (as used by org.springframework.transaction.jta.JtaTransactionManager ), for proper after-completion callbacks. Therefore, as long as Spring's JtaTransactionManager drives the JTA transactions, Hibernate does not require any special configuration for proper JTA participation. Note that there are special restrictions with EJB CMT and restrictive JTA subsystems: See org.springframework.transaction.jta.JtaTransactionManager 's javadoc for details.

On JDBC 3.0, this transaction manager supports nested transactions via JDBC 3.0 Savepoints. The HibernateTransactionManager.setNestedTransactionAllowed "nestedTransactionAllowed"} flag defaults to "false", though, as nested transactions will just apply to the JDBC Connection, not to the Hibernate Session 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 Hibernate transactions (provided that your JDBC driver supports Savepoints). Note that Hibernate itself does not support nested transactions! Hence, do not expect Hibernate access code to semantically participate in a nested transaction.

Note: Spring's Hibernate support in this package requires Hibernate 2.1. Dedicated Hibernate3 support can be found in a separate package: org.springframework.orm.hibernate3.
author:
   Juergen Hoeller
since:
   02.05.2003
See Also:   HibernateTransactionManager.setSessionFactory
See Also:   HibernateTransactionManager.setDataSource
See Also:   LocalSessionFactoryBean
See Also:   SessionFactoryUtils.getSession
See Also:   SessionFactoryUtils.applyTransactionTimeout
See Also:   SessionFactoryUtils.releaseSession
See Also:   HibernateTemplate.execute
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

If the SessionFactory was configured with LocalDataSourceConnectionProvider, i.e.

Such an interceptor can either be set at the SessionFactory level, i.e.

Requires the bean factory to be known, to be able to resolve the bean name to an interceptor instance on session creation.

Creates a default SQLErrorCodeSQLExceptionTranslator or SQLStateSQLExceptionTranslator for the specified SessionFactory, if no exception translator explicitly specified.
See Also:   HibernateTransactionManager.setJdbcExceptionTranslator

Can be turned off to deliberately ignore an available DataSource, to not expose Hibernate transactions as JDBC transactions for that DataSource.
See Also:   HibernateTransactionManager.setDataSource
See Also:   LocalSessionFactoryBean.setDataSource

If the SessionFactory was configured with LocalDataSourceConnectionProvider, i.e. by Spring's LocalSessionFactoryBean with a specified "dataSource", the DataSource will be autodetected: You can still explictly specify the DataSource, but you don't need to in this case.

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 Hibernate Session.

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:   HibernateTransactionManager.setAutodetectDataSource
See Also:   LocalDataSourceConnectionProvider
See Also:   LocalSessionFactoryBean.setDataSource
See Also:   org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy
See Also:   org.springframework.jdbc.datasource.DataSourceUtils
See Also:   org.springframework.jdbc.core.JdbcTemplate

Such an interceptor can either be set at the SessionFactory level, i.e. on LocalSessionFactoryBean, or at the Session level, i.e. on HibernateTemplate, HibernateInterceptor, and HibernateTransactionManager. It's preferable to set it on LocalSessionFactoryBean or HibernateTransactionManager to avoid repeated configuration and guarantee consistent behavior in transactions.
See Also:   LocalSessionFactoryBean.setEntityInterceptor
See Also:   HibernateTemplate.setEntityInterceptor
See Also:   HibernateInterceptor.setEntityInterceptor

Requires the bean factory to be known, to be able to resolve the bean name to an interceptor instance on session creation. Typically used for prototype interceptors, i.e. a new interceptor instance per session.

Can also be used for shared interceptor instances, but it is recommended to set the interceptor reference directly in such a scenario.
Parameters:
  entityInterceptorBeanName - the name of the entity interceptor inthe bean factory
See Also:   HibernateTransactionManager.setBeanFactory
See Also:   HibernateTransactionManager.setEntityInterceptor

The default exception translator is either a SQLErrorCodeSQLExceptionTranslator if a DataSource is available, or a SQLStateSQLExceptionTranslator else.
Parameters:
  jdbcExceptionTranslator - the exception translator
See Also:   java.sql.SQLException
See Also:   net.sf.hibernate.JDBCException
See Also:   SessionFactoryUtils.newJdbcExceptionTranslator
See Also:   org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator
See Also:   org.springframework.jdbc.support.SQLStateSQLExceptionTranslator