org.springframework.orm.hibernate
Class HibernateTransactionManager

org.springframework.transaction.support.AbstractPlatformTransactionManager
  |
  +--org.springframework.orm.hibernate.HibernateTransactionManager

public class HibernateTransactionManager

extends AbstractPlatformTransactionManager

implements InitializingBean

PlatformTransactionManager implementation for single Hibernate session factories. Binds a Hibernate Session from the specified factory to the thread, potentially allowing for one thread Session per factory. SessionFactoryUtils and HibernateTemplate are aware of thread-bound Sessions and participate in such transactions automatically. Using either is required for Hibernate access code that needs to support this transaction handling mechanism.

Supports custom isolation levels, and timeouts that get applied as appropriate Hibernate query timeouts. To support the latter, application code must either use HibernateTemplate.find or call SessionFactoryUtils' applyTransactionTimeout method for each created Hibernate Query object.

This implementation is appropriate for applications that solely use Hibernate for transactional data access, but it also supports direct data source access within a transaction (i.e. plain JDBC code working with the same DataSource). This allows for mixing services that access Hibernate (including transactional caching) and services that use plain JDBC (without being aware of Hibernate)! Application code needs to stick to the same simple Connection lookup pattern as with DataSourceTransactionManager (i.e. DataSourceUtils.getConnection).

Note that to be able to register a DataSource's Connection for plain JDBC code, this instance needs to be aware of the DataSource (see 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 by supplying the same DataSource to LocalSessionFactoryBean. In the latter case, the Hibernate settings do not have to define a connection provider at all, avoiding duplicated configuration.

JTA respectively JtaTransactionManager is necessary for accessing multiple transactional resources. The DataSource that Hibernate uses needs to be JTA-enabled then (see container setup), alternatively the Hibernate JCA connector can be used for direct container integration. 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. Using the JCA Connector can solve this but involves packaging issue and container-specific connector deployment.

Fortunately, there is an easier way with Spring: SessionFactoryUtils (and thus HibernateTemplate) registers synchronizations with TransactionSynchronizationManager (as used by JtaTransactionManager), for proper afterCompletion 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 cases with EJB CMT and restrictive JTA subsystems: See JtaTransactionManager's javadoc for details.

Note: Spring's Hibernate support requires Hibernate 2.x (2.1 recommended). For using JtaTransactionManager with Hibernate, Hibernate 2.1 is required.

Author:

Juergen Hoeller

Since: 02.05.2003

See Also: SessionFactoryUtils.getSession(SessionFactory,boolean), SessionFactoryUtils.applyTransactionTimeout(Query,SessionFactory), SessionFactoryUtils.closeSessionIfNecessary(Session,SessionFactory), HibernateTemplate.execute(org.springframework.orm.hibernate.HibernateCallback), org.springframework.jdbc.datasource.DataSourceUtils.getConnection(javax.sql.DataSource), org.springframework.jdbc.datasource.DataSourceUtils.applyTransactionTimeout(java.sql.Statement,javax.sql.DataSource), org.springframework.jdbc.datasource.DataSourceUtils.closeConnectionIfNecessary(java.sql.Connection,javax.sql.DataSource), JdbcTemplate, DataSourceTransactionManager

Constructor Summary

HibernateTransactionManager()           Create a new HibernateTransactionManager instance.

HibernateTransactionManager(SessionFactory sessionFactory)           Create a new HibernateTransactionManager instance.

Method Summary
void	afterPropertiesSet()
DataSource	getDataSource()           Return the JDBC DataSource that this instance manages transactions for.
Interceptor	getEntityInterceptor()           Return the current Hibernate entity interceptor, or null if none.
SQLExceptionTranslator	getJdbcExceptionTranslator()           Return the JDBC exception translator for this transaction manager.
SessionFactory	getSessionFactory()           Return the SessionFactory that this instance should manage transactions for.
void	setDataSource(DataSource dataSource)           Set the JDBC DataSource that this instance should manage transactions for.
void	setEntityInterceptor(Interceptor entityInterceptor)           Set a Hibernate entity interceptor that allows to inspect and change property values before writing to and reading from the database.
void	setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)           Set the JDBC exception translator for this transaction manager.
void	setSessionFactory(SessionFactory sessionFactory)           Set the SessionFactory that this instance should manage transactions for.

Methods inherited from class org.springframework.transaction.support.AbstractPlatformTransactionManager

commit, getTransaction, getTransactionSynchronization, isRollbackOnCommitFailure, rollback, setRollbackOnCommitFailure, setTransactionSynchronization, setTransactionSynchronizationName

Constructor Detail

HibernateTransactionManager

public HibernateTransactionManager()

Create a new HibernateTransactionManager instance. A SessionFactory has to be set to be able to use it.

See Also:

setSessionFactory(SessionFactory)

public HibernateTransactionManager(SessionFactory sessionFactory)

Create a new HibernateTransactionManager instance.

Parameters:

sessionFactory - SessionFactory to manage transactions for

public void afterPropertiesSet()

public DataSource getDataSource()

Return the JDBC DataSource that this instance manages transactions for.

public Interceptor getEntityInterceptor()

Return the current Hibernate entity interceptor, or null if none.

public SQLExceptionTranslator getJdbcExceptionTranslator()

Return the JDBC exception translator for this transaction manager.

public SessionFactory getSessionFactory()

Return the SessionFactory that this instance should manage transactions for.

public void setDataSource(DataSource dataSource)

Set the JDBC DataSource that this instance should manage transactions for. The DataSource should match the one used by the Hibernate SessionFactory.

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.

public void setEntityInterceptor(Interceptor entityInterceptor)

Set a Hibernate entity interceptor that allows to inspect and change property values before writing to and reading from the database. Will get applied to any new Session created by this transaction manager.

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(Interceptor), HibernateAccessor.setEntityInterceptor(Interceptor), HibernateAccessor.setEntityInterceptor(Interceptor)

public void setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)

Set the JDBC exception translator for this transaction manager. Applied to SQLExceptions (wrapped by Hibernate's JDBCException) thrown by flushing on commit.

The default exception translator evaluates the exception's SQLState.

Parameters:

jdbcExceptionTranslator - exception translator

See Also:

SQLStateSQLExceptionTranslator, SQLErrorCodeSQLExceptionTranslator

public void setSessionFactory(SessionFactory sessionFactory)

Set the SessionFactory that this instance should manage transactions for.

Association Links

to Class javax.sql.DataSource

to Class org.springframework.jdbc.support.SQLExceptionTranslator