org.springframework.orm.hibernate3
Class SessionFactoryUtils

java.lang.Object
  org.springframework.orm.hibernate3.SessionFactoryUtils

public abstract class SessionFactoryUtils
extends java.lang.Object

Helper class featuring methods for Hibernate Session handling, allowing for reuse of Hibernate Session instances within transactions. Also provides support for exception translation.

Supports synchronization with both Spring-managed JTA transactions (see JtaTransactionManager) and non-Spring JTA transactions (i.e. plain JTA or EJB CMT), transparently providing transaction-scoped Hibernate Sessions. Note that for non-Spring JTA transactions, a JTA TransactionManagerLookup has to be specified in the Hibernate configuration.

Used internally by HibernateTemplate, HibernateInterceptor and HibernateTransactionManager. Can also be used directly in application code.

Since:

1.2

Author:

Juergen Hoeller

See Also:

getSession(SessionFactory, boolean), releaseSession(Session, SessionFactory), HibernateTransactionManager, JtaTransactionManager, TransactionSynchronizationManager

Field Summary

private static java.lang.ThreadLocal<java.util.Map<SessionFactory,java.util.Set<Session>>>	deferredCloseHolder
(package private) static Log	logger
static int	SESSION_SYNCHRONIZATION_ORDER Order value for TransactionSynchronization objects that clean up Hibernate Sessions.

Constructor Summary

SessionFactoryUtils()

Method Summary

static void	applyTransactionTimeout(Criteria criteria, SessionFactory sessionFactory) Apply the current transaction timeout, if any, to the given Hibernate Criteria object.
static void	applyTransactionTimeout(Query query, SessionFactory sessionFactory) Apply the current transaction timeout, if any, to the given Hibernate Query object.
static void	closeSession(Session session) Perform actual closing of the Hibernate Session, catching and logging any cleanup exceptions thrown.
(package private) static void	closeSessionOrRegisterDeferredClose(Session session, SessionFactory sessionFactory) Close the given Session or register it for deferred close.
static DataAccessException	convertHibernateAccessException(HibernateException ex) Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.
static Session	doGetSession(SessionFactory sessionFactory, boolean allowCreate) Get a Hibernate Session for the given SessionFactory.
private static Session	doGetSession(SessionFactory sessionFactory, Interceptor entityInterceptor, SQLExceptionTranslator jdbcExceptionTranslator, boolean allowCreate) Get a Hibernate Session for the given SessionFactory.
static javax.sql.DataSource	getDataSource(SessionFactory sessionFactory) Determine the DataSource of the given SessionFactory.
private static Session	getJtaSynchronizedSession(SessionHolder sessionHolder, SessionFactory sessionFactory, SQLExceptionTranslator jdbcExceptionTranslator) Retrieve a Session from the given SessionHolder, potentially from a JTA transaction synchronization.
static TransactionManager	getJtaTransactionManager(SessionFactory sessionFactory, Session session) Try to retrieve the JTA TransactionManager from the given SessionFactory and/or Session.
static Session	getNewSession(SessionFactory sessionFactory) Get a new Hibernate Session from the given SessionFactory.
static Session	getNewSession(SessionFactory sessionFactory, Interceptor entityInterceptor) Get a new Hibernate Session from the given SessionFactory.
static Session	getSession(SessionFactory sessionFactory, boolean allowCreate) Get a Hibernate Session for the given SessionFactory.
static Session	getSession(SessionFactory sessionFactory, Interceptor entityInterceptor, SQLExceptionTranslator jdbcExceptionTranslator) Get a Hibernate Session for the given SessionFactory.
static boolean	hasTransactionalSession(SessionFactory sessionFactory) Return whether there is a transactional Hibernate Session for the current thread, that is, a Session bound to the current thread by Spring's transaction facilities.
static void	initDeferredClose(SessionFactory sessionFactory) Initialize deferred close for the current thread and the given SessionFactory.
static boolean	isDeferredCloseActive(SessionFactory sessionFactory) Determine whether deferred close is active for the current thread and the given SessionFactory.
static boolean	isSessionTransactional(Session session, SessionFactory sessionFactory) Return whether the given Hibernate Session is transactional, that is, bound to the current thread by Spring's transaction facilities.
static SQLExceptionTranslator	newJdbcExceptionTranslator(SessionFactory sessionFactory) Create an appropriate SQLExceptionTranslator for the given SessionFactory.
static void	processDeferredClose(SessionFactory sessionFactory) Process all Hibernate Sessions that have been registered for deferred close for the given SessionFactory.
private static void	registerJtaSynchronization(Session session, SessionFactory sessionFactory, SQLExceptionTranslator jdbcExceptionTranslator, SessionHolder sessionHolder) Register a JTA synchronization for the given Session, if any.
static void	releaseSession(Session session, SessionFactory sessionFactory) Close the given Session, created via the given factory, if it is not managed externally (i.e.
static java.lang.String	toString(Session session) Stringify the given Session for debug logging.

Methods inherited from class java.lang.Object

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

Field Detail

SESSION_SYNCHRONIZATION_ORDER

public static final int SESSION_SYNCHRONIZATION_ORDER

Order value for TransactionSynchronization objects that clean up Hibernate Sessions. Returns DataSourceUtils.CONNECTION_SYNCHRONIZATION_ORDER - 100 to execute Session cleanup before JDBC Connection cleanup, if any.

See Also:

DataSourceUtils.CONNECTION_SYNCHRONIZATION_ORDER, Constant Field Values

logger

static final Log logger

deferredCloseHolder

private static final java.lang.ThreadLocal<java.util.Map<SessionFactory,java.util.Set<Session>>> deferredCloseHolder

Constructor Detail

SessionFactoryUtils

public SessionFactoryUtils()

Method Detail

getDataSource

public static javax.sql.DataSource getDataSource(SessionFactory sessionFactory)

Determine the DataSource of the given SessionFactory.

Parameters:

sessionFactory - the SessionFactory to check

Returns:

the DataSource, or null if none found

See Also:

org.hibernate.engine.SessionFactoryImplementor#getConnectionProvider, LocalDataSourceConnectionProvider

newJdbcExceptionTranslator

public static SQLExceptionTranslator newJdbcExceptionTranslator(SessionFactory sessionFactory)

Create an appropriate SQLExceptionTranslator for the given SessionFactory. If a DataSource is found, a SQLErrorCodeSQLExceptionTranslator for the DataSource is created; else, a SQLStateSQLExceptionTranslator as fallback.

Parameters:

sessionFactory - the SessionFactory to create the translator for

Returns:

the SQLExceptionTranslator

See Also:

getDataSource(SessionFactory), SQLErrorCodeSQLExceptionTranslator, SQLStateSQLExceptionTranslator

getJtaTransactionManager

public static TransactionManager getJtaTransactionManager(SessionFactory sessionFactory,
                                                          Session session)

Try to retrieve the JTA TransactionManager from the given SessionFactory and/or Session. Check the passed-in SessionFactory for implementing SessionFactoryImplementor (the usual case), falling back to the SessionFactory reference that the Session itself carries.

Parameters:

sessionFactory - Hibernate SessionFactory

session - Hibernate Session (can also be null)

Returns:

the JTA TransactionManager, if any

See Also:

javax.transaction.TransactionManager, SessionFactoryImplementor#getTransactionManager, Session#getSessionFactory, org.hibernate.impl.SessionFactoryImpl

getSession

public static Session getSession(SessionFactory sessionFactory,
                                 boolean allowCreate)
                          throws DataAccessResourceFailureException,
                                 java.lang.IllegalStateException

Get a Hibernate Session for the given SessionFactory. Is aware of and will return any existing corresponding Session bound to the current thread, for example when using HibernateTransactionManager. Will create a new Session otherwise, if "allowCreate" is true.

This is the getSession method used by typical data access code, in combination with releaseSession called when done with the Session. Note that HibernateTemplate allows to write data access code without caring about such resource handling.

Parameters:

sessionFactory - Hibernate SessionFactory to create the session with

allowCreate - whether a non-transactional Session should be created when no transactional Session can be found for the current thread

Returns:

the Hibernate Session

Throws:

DataAccessResourceFailureException - if the Session couldn't be created

java.lang.IllegalStateException - if no thread-bound Session found and "allowCreate" is false

See Also:

getSession(SessionFactory, Interceptor, SQLExceptionTranslator), releaseSession(Session, SessionFactory), HibernateTemplate

getSession

public static Session getSession(SessionFactory sessionFactory,
                                 Interceptor entityInterceptor,
                                 SQLExceptionTranslator jdbcExceptionTranslator)
                          throws DataAccessResourceFailureException

Get a Hibernate Session for the given SessionFactory. Is aware of and will return any existing corresponding Session bound to the current thread, for example when using HibernateTransactionManager. Will always create a new Session otherwise.

Supports setting a Session-level Hibernate entity interceptor that allows to inspect and change property values before writing to and reading from the database. Such an interceptor can also be set at the SessionFactory level (i.e. on LocalSessionFactoryBean), on HibernateTransactionManager, or on HibernateInterceptor/HibernateTemplate.

Parameters:

sessionFactory - Hibernate SessionFactory to create the session with

entityInterceptor - Hibernate entity interceptor, or null if none

jdbcExceptionTranslator - SQLExcepionTranslator to use for flushing the Session on transaction synchronization (may be null; only used when actually registering a transaction synchronization)

Returns:

the Hibernate Session

Throws:

DataAccessResourceFailureException - if the Session couldn't be created

See Also:

LocalSessionFactoryBean.setEntityInterceptor(Interceptor), HibernateAccessor.setEntityInterceptor(Interceptor), HibernateAccessor.setEntityInterceptor(Interceptor)

doGetSession

public static Session doGetSession(SessionFactory sessionFactory,
                                   boolean allowCreate)
                            throws HibernateException,
                                   java.lang.IllegalStateException

Get a Hibernate Session for the given SessionFactory. Is aware of and will return any existing corresponding Session bound to the current thread, for example when using HibernateTransactionManager. Will create a new Session otherwise, if "allowCreate" is true.

Throws the original HibernateException, in contrast to getSession(SessionFactory, boolean).

Parameters:

sessionFactory - Hibernate SessionFactory to create the session with

allowCreate - whether a non-transactional Session should be created when no transactional Session can be found for the current thread

Returns:

the Hibernate Session

Throws:

HibernateException - if the Session couldn't be created

java.lang.IllegalStateException - if no thread-bound Session found and allowCreate false

doGetSession

private static Session doGetSession(SessionFactory sessionFactory,
                                    Interceptor entityInterceptor,
                                    SQLExceptionTranslator jdbcExceptionTranslator,
                                    boolean allowCreate)
                             throws HibernateException,
                                    java.lang.IllegalStateException

Get a Hibernate Session for the given SessionFactory. Is aware of and will return any existing corresponding Session bound to the current thread, for example when using HibernateTransactionManager. Will create a new Session otherwise, if "allowCreate" is true.

Same as getSession(SessionFactory, boolean), but throwing the original HibernateException.

Parameters:

sessionFactory - Hibernate SessionFactory to create the session with

entityInterceptor - Hibernate entity interceptor, or null if none

jdbcExceptionTranslator - SQLExcepionTranslator to use for flushing the Session on transaction synchronization (may be null)

allowCreate - whether a non-transactional Session should be created when no transactional Session can be found for the current thread

Returns:

the Hibernate Session

Throws:

HibernateException - if the Session couldn't be created

java.lang.IllegalStateException - if no thread-bound Session found and "allowCreate" is false

getJtaSynchronizedSession

private static Session getJtaSynchronizedSession(SessionHolder sessionHolder,
                                                 SessionFactory sessionFactory,
                                                 SQLExceptionTranslator jdbcExceptionTranslator)
                                          throws DataAccessResourceFailureException

Retrieve a Session from the given SessionHolder, potentially from a JTA transaction synchronization.

Parameters:

sessionHolder - the SessionHolder to check

sessionFactory - the SessionFactory to get the JTA TransactionManager from

jdbcExceptionTranslator - SQLExcepionTranslator to use for flushing the Session on transaction synchronization (may be null)

Returns:

the associated Session, if any

Throws:

DataAccessResourceFailureException - if the Session couldn't be created

registerJtaSynchronization

private static void registerJtaSynchronization(Session session,
                                               SessionFactory sessionFactory,
                                               SQLExceptionTranslator jdbcExceptionTranslator,
                                               SessionHolder sessionHolder)

Register a JTA synchronization for the given Session, if any.

Parameters:

sessionHolder - the existing thread-bound SessionHolder, if any

session - the Session to register

sessionFactory - the SessionFactory that the Session was created with

jdbcExceptionTranslator - SQLExcepionTranslator to use for flushing the Session on transaction synchronization (may be null)

getNewSession

public static Session getNewSession(SessionFactory sessionFactory)

Get a new Hibernate Session from the given SessionFactory. Will return a new Session even if there already is a pre-bound Session for the given SessionFactory.

Within a transaction, this method will create a new Session that shares the transaction's JDBC Connection. More specifically, it will use the same JDBC Connection as the pre-bound Hibernate Session.

Parameters:

sessionFactory - Hibernate SessionFactory to create the session with

Returns:

the new Session

getNewSession

public static Session getNewSession(SessionFactory sessionFactory,
                                    Interceptor entityInterceptor)

Get a new Hibernate Session from the given SessionFactory. Will return a new Session even if there already is a pre-bound Session for the given SessionFactory.

Within a transaction, this method will create a new Session that shares the transaction's JDBC Connection. More specifically, it will use the same JDBC Connection as the pre-bound Hibernate Session.

Parameters:

sessionFactory - Hibernate SessionFactory to create the session with

entityInterceptor - Hibernate entity interceptor, or null if none

Returns:

the new Session

toString

public static java.lang.String toString(Session session)

Stringify the given Session for debug logging. Returns output equivalent to Object.toString(): the fully qualified class name + "@" + the identity hash code.

The sole reason why this is necessary is because Hibernate3's Session.toString() implementation is broken (and won't be fixed): it logs the toString representation of all persistent objects in the Session, which might lead to ConcurrentModificationExceptions if the persistent objects in turn refer to the Session (for example, for lazy loading).

Parameters:

session - the Hibernate Session to stringify

Returns:

the String representation of the given Session

hasTransactionalSession

public static boolean hasTransactionalSession(SessionFactory sessionFactory)

Return whether there is a transactional Hibernate Session for the current thread, that is, a Session bound to the current thread by Spring's transaction facilities.

Parameters:

sessionFactory - Hibernate SessionFactory to check (may be null)

Returns:

whether there is a transactional Session for current thread

isSessionTransactional

public static boolean isSessionTransactional(Session session,
                                             SessionFactory sessionFactory)

Return whether the given Hibernate Session is transactional, that is, bound to the current thread by Spring's transaction facilities.

Parameters:

session - the Hibernate Session to check

sessionFactory - Hibernate SessionFactory that the Session was created with (may be null)

Returns:

whether the Session is transactional

applyTransactionTimeout

public static void applyTransactionTimeout(Query query,
                                           SessionFactory sessionFactory)

Apply the current transaction timeout, if any, to the given Hibernate Query object.

Parameters:

query - the Hibernate Query object

sessionFactory - Hibernate SessionFactory that the Query was created for (may be null)

See Also:

org.hibernate.Query#setTimeout

applyTransactionTimeout

public static void applyTransactionTimeout(Criteria criteria,
                                           SessionFactory sessionFactory)

Apply the current transaction timeout, if any, to the given Hibernate Criteria object.

Parameters:

criteria - the Hibernate Criteria object

sessionFactory - Hibernate SessionFactory that the Criteria was created for

See Also:

org.hibernate.Criteria#setTimeout

convertHibernateAccessException

public static DataAccessException convertHibernateAccessException(HibernateException ex)

Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.

Parameters:

ex - HibernateException that occured

Returns:

the corresponding DataAccessException instance

See Also:

HibernateAccessor.convertHibernateAccessException(HibernateException), HibernateTransactionManager.convertHibernateAccessException(HibernateException)

isDeferredCloseActive

public static boolean isDeferredCloseActive(SessionFactory sessionFactory)

Determine whether deferred close is active for the current thread and the given SessionFactory.

Parameters:

sessionFactory - the Hibernate SessionFactory to check

Returns:

whether deferred close is active

initDeferredClose

public static void initDeferredClose(SessionFactory sessionFactory)

Initialize deferred close for the current thread and the given SessionFactory. Sessions will not be actually closed on close calls then, but rather at a processDeferredClose(SessionFactory) call at a finishing point (like request completion).

Used by OpenSessionInViewFilter and OpenSessionInViewInterceptor when not configured for a single session.

Parameters:

sessionFactory - the Hibernate SessionFactory to initialize deferred close for

See Also:

processDeferredClose(SessionFactory), releaseSession(Session, SessionFactory), OpenSessionInViewFilter.setSingleSession(boolean), OpenSessionInViewInterceptor.setSingleSession(boolean)

processDeferredClose

public static void processDeferredClose(SessionFactory sessionFactory)

Process all Hibernate Sessions that have been registered for deferred close for the given SessionFactory.

Parameters:

sessionFactory - the Hibernate SessionFactory to process deferred close for

See Also:

initDeferredClose(SessionFactory), releaseSession(Session, SessionFactory)

releaseSession

public static void releaseSession(Session session,
                                  SessionFactory sessionFactory)

Close the given Session, created via the given factory, if it is not managed externally (i.e. not bound to the thread).

Parameters:

session - the Hibernate Session to close (may be null)

sessionFactory - Hibernate SessionFactory that the Session was created with (may be null)

closeSessionOrRegisterDeferredClose

static void closeSessionOrRegisterDeferredClose(Session session,
                                                SessionFactory sessionFactory)

Close the given Session or register it for deferred close.

Parameters:

session - the Hibernate Session to close

sessionFactory - Hibernate SessionFactory that the Session was created with (may be null)

See Also:

initDeferredClose(SessionFactory), processDeferredClose(SessionFactory)

closeSession

public static void closeSession(Session session)

Perform actual closing of the Hibernate Session, catching and logging any cleanup exceptions thrown.

Parameters:

session - the Hibernate Session to close (may be null)

See Also:

org.hibernate.Session#close()