HibernateTransactionManager (Spring Framework)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.springframework.orm.hibernate
Class HibernateTransactionManager

java.lang.Object
  org.springframework.transaction.support.AbstractPlatformTransactionManager
      org.springframework.orm.hibernate.HibernateTransactionManager

All Implemented Interfaces:: InitializingBean, PlatformTransactionManager

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 with LocalSessionFactoryBean and a local DataSource (which will be auto-detected by this transaction manager). 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.1 (as of Spring 1.0).

Since:: 02.05.2003
Author:: Juergen Hoeller
See Also:: setSessionFactory(net.sf.hibernate.SessionFactory), setDataSource(javax.sql.DataSource), SessionFactoryUtils.getSession(net.sf.hibernate.SessionFactory, boolean), SessionFactoryUtils.applyTransactionTimeout(net.sf.hibernate.Query, net.sf.hibernate.SessionFactory), SessionFactoryUtils.closeSessionIfNecessary(net.sf.hibernate.Session, net.sf.hibernate.SessionFactory), HibernateTemplate.execute(org.springframework.orm.hibernate.HibernateCallback), DataSourceUtils.getConnection(javax.sql.DataSource), DataSourceUtils.applyTransactionTimeout(java.sql.Statement, javax.sql.DataSource), DataSourceUtils.closeConnectionIfNecessary(java.sql.Connection, javax.sql.DataSource), JdbcTemplate, DataSourceTransactionManager

Field Summary

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

logger, SYNCHRONIZATION_ALWAYS, SYNCHRONIZATION_NEVER, SYNCHRONIZATION_ON_ACTUAL_TRANSACTION

Constructor Summary
`HibernateTransactionManager()` Create a new HibernateTransactionManager instance.
`HibernateTransactionManager(net.sf.hibernate.SessionFactory sessionFactory)` Create a new HibernateTransactionManager instance.

Method Summary
`void`	`afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
`protected DataAccessException`	`convertHibernateAccessException(net.sf.hibernate.HibernateException ex)` Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.
`protected DataAccessException`	`convertJdbcAccessException(java.sql.SQLException ex)` Convert the given SQLException to an appropriate exception from the org.springframework.dao hierarchy.
`protected void`	`doBegin(java.lang.Object transaction, TransactionDefinition definition)` Begin a new transaction with the given transaction definition.
`protected void`	`doCleanupAfterCompletion(java.lang.Object transaction)` Cleanup resources after transaction completion.
`protected void`	`doCommit(DefaultTransactionStatus status)` Perform an actual commit on the given transaction.
`protected java.lang.Object`	`doGetTransaction()` Return a current transaction object, i.e. a JTA UserTransaction.
`protected void`	`doResume(java.lang.Object transaction, java.lang.Object suspendedResources)` Resume the resources of the current transaction.
`protected void`	`doRollback(DefaultTransactionStatus status)` Perform an actual rollback on the given transaction.
`protected void`	`doSetRollbackOnly(DefaultTransactionStatus status)` Set the given transaction rollback-only.
`protected java.lang.Object`	`doSuspend(java.lang.Object transaction)` Suspend the resources of the current transaction.
`javax.sql.DataSource`	`getDataSource()` Return the JDBC DataSource that this instance manages transactions for.
`net.sf.hibernate.Interceptor`	`getEntityInterceptor()` Return the current Hibernate entity interceptor, or null if none.
`SQLExceptionTranslator`	`getJdbcExceptionTranslator()` Return the JDBC exception translator for this transaction manager.
`net.sf.hibernate.SessionFactory`	`getSessionFactory()` Return the SessionFactory that this instance should manage transactions for.
`protected boolean`	`isExistingTransaction(java.lang.Object transaction)` Check if the given transaction object indicates an existing, i.e. already begun, transaction.
`protected boolean`	`isRollbackOnly(java.lang.Object transaction)` Check if the given transaction object indicates a rollback-only, assumably from a nested transaction (else, the TransactionStatus of this transaction would have indicated rollback-only).
`void`	`setDataSource(javax.sql.DataSource dataSource)` Set the JDBC DataSource that this instance should manage transactions for.
`void`	`setEntityInterceptor(net.sf.hibernate.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(net.sf.hibernate.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

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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(net.sf.hibernate.SessionFactory)

HibernateTransactionManager

public HibernateTransactionManager(net.sf.hibernate.SessionFactory sessionFactory)

Create a new HibernateTransactionManager instance.
Parameters:: sessionFactory - SessionFactory to manage transactions for

Method Detail

setSessionFactory

public void setSessionFactory(net.sf.hibernate.SessionFactory sessionFactory)

Set the SessionFactory that this instance should manage transactions for.

getSessionFactory

public net.sf.hibernate.SessionFactory getSessionFactory()

Return the SessionFactory that this instance should manage transactions for.

setDataSource

public void setDataSource(javax.sql.DataSource dataSource)

Set the JDBC DataSource that this instance should manage transactions for. The DataSource should match the one used by the Hibernate SessionFactory: for example, you could specify the same JNDI DataSource for both.

If the SessionFactory was configured with LocalDataSourceConnectionProvider, i.e. by Spring's LocalSessionFactoryBean with a specified "dataSource", the DataSource will be auto-detected: 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.

See Also:: LocalDataSourceConnectionProvider, LocalSessionFactoryBean.setDataSource(javax.sql.DataSource)

getDataSource

public javax.sql.DataSource getDataSource()

Return the JDBC DataSource that this instance manages transactions for.

setEntityInterceptor

public void setEntityInterceptor(net.sf.hibernate.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(net.sf.hibernate.Interceptor), HibernateAccessor.setEntityInterceptor(net.sf.hibernate.Interceptor), HibernateAccessor.setEntityInterceptor(net.sf.hibernate.Interceptor)

getEntityInterceptor

public net.sf.hibernate.Interceptor getEntityInterceptor()

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

setJdbcExceptionTranslator

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

getJdbcExceptionTranslator

public SQLExceptionTranslator getJdbcExceptionTranslator()

Return the JDBC exception translator for this transaction manager.

afterPropertiesSet

public void afterPropertiesSet()

Description copied from interface: InitializingBean

Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

Specified by:: afterPropertiesSet in interface InitializingBean