org.springframework.orm.hibernate
Class HibernateAccessor

java.lang.Object
  org.springframework.orm.hibernate.HibernateAccessor

All Implemented Interfaces:

InitializingBean

Direct Known Subclasses:

HibernateInterceptor, HibernateTemplate, OpenSessionInViewInterceptor

public abstract class HibernateAccessor
extends Object
implements InitializingBean

Base class for HibernateTemplate and HibernateInterceptor, defining common properties like SessionFactory and flushing behavior.

Not intended to be used directly. See HibernateTemplate and HibernateInterceptor.

Since:

29.07.2003

Author:

Juergen Hoeller

See Also:

HibernateTemplate, HibernateInterceptor, setFlushMode(int)

Field Summary

static int	FLUSH_AUTO Automatic flushing is the default mode for a Hibernate session.
static int	FLUSH_EAGER Eager flushing leads to immediate synchronization with the database, even if in a transaction.
static int	FLUSH_NEVER Never flush is a good strategy for read-only units of work.
protected Log	logger

Constructor Summary

HibernateAccessor()

Method Summary

void	afterPropertiesSet() Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
DataAccessException	convertHibernateAccessException(HibernateException ex) Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.
protected DataAccessException	convertJdbcAccessException(JDBCException ex) Convert the given JDBCException to an appropriate exception from the org.springframework.dao hierarchy.
protected DataAccessException	convertJdbcAccessException(SQLException ex) Convert the given SQLException to an appropriate exception from the org.springframework.dao hierarchy.
protected void	flushIfNecessary(Session session, boolean existingTransaction) Flush the given Hibernate Session if necessary.
Interceptor	getEntityInterceptor() Return the current Hibernate entity interceptor, or null if none.
int	getFlushMode() Return if a flush should be forced after executing the callback code.
SQLExceptionTranslator	getJdbcExceptionTranslator() Return the JDBC exception translator for this instance.
SessionFactory	getSessionFactory() Return the Hibernate SessionFactory that should be used to create Hibernate Sessions.
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	setFlushMode(int flushMode) Set the flush behavior to one of the constants in this class.
void	setFlushModeName(String constantName) Set the flush behavior by the name of the respective constant in this class, e.g.
void	setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator) Set the JDBC exception translator for this instance.
void	setSessionFactory(SessionFactory sessionFactory) Set the Hibernate SessionFactory that should be used to create Hibernate Sessions.

Methods inherited from class java.lang.Object

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

Field Detail

FLUSH_NEVER

public static final int FLUSH_NEVER

Never flush is a good strategy for read-only units of work. Hibernate will not track and look for changes in this case, avoiding any overhead of modification detection.

See Also:

setFlushMode(int), Constant Field Values

FLUSH_AUTO

public static final int FLUSH_AUTO

Automatic flushing is the default mode for a Hibernate session. A session will get flushed on transaction commit or session closing, and on certain find operations that might involve already modified instances, but not after each unit of work like with eager flushing.

See Also:

setFlushMode(int), Constant Field Values

FLUSH_EAGER

public static final int FLUSH_EAGER

Eager flushing leads to immediate synchronization with the database, even if in a transaction. This causes inconsistencies to show up and throw a respective exception immediately, and JDBC access code that participates in the same transaction will see the changes as the database is already aware of them then. But the drawbacks are:

• additional communication roundtrips with the database, instead of a single batch at transaction commit;
• the fact that an actual database rollback is needed if the Hibernate transaction rolls back (due to already submitted SQL statements).

See Also:

setFlushMode(int), Constant Field Values

logger

protected final Log logger

Constructor Detail

HibernateAccessor

public HibernateAccessor()

Method Detail

setSessionFactory

public void setSessionFactory(SessionFactory sessionFactory)

Set the Hibernate SessionFactory that should be used to create Hibernate Sessions.

getSessionFactory

public SessionFactory getSessionFactory()

Return the Hibernate SessionFactory that should be used to create Hibernate Sessions.

setEntityInterceptor

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 object.

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

getEntityInterceptor

public 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 instance. Applied to SQLExceptions thrown by callback code, be it direct SQLExceptions or wrapped Hibernate JDBCExceptions.

The default exception translator is either a SQLErrorCodeSQLExceptionTranslator if a DataSource is available, or a SQLStateSQLExceptionTranslator else.

Parameters:

jdbcExceptionTranslator - the exception translator

See Also:

SQLException, JDBCException, SessionFactoryUtils.newJdbcExceptionTranslator(net.sf.hibernate.SessionFactory), SQLErrorCodeSQLExceptionTranslator, SQLStateSQLExceptionTranslator

getJdbcExceptionTranslator

public SQLExceptionTranslator getJdbcExceptionTranslator()

Return the JDBC exception translator for this instance.

Creates a default SQLErrorCodeSQLExceptionTranslator or SQLStateSQLExceptionTranslator for the specified SessionFactory, if no exception translator explicitly specified.

setFlushModeName

public void setFlushModeName(String constantName)

Set the flush behavior by the name of the respective constant in this class, e.g. "FLUSH_AUTO". Default is FLUSH_AUTO. Will get applied to any new Session created by this object.

Parameters:

constantName - name of the constant

See Also:

setFlushMode(int), FLUSH_AUTO

setFlushMode

public void setFlushMode(int flushMode)

Set the flush behavior to one of the constants in this class. Default is FLUSH_AUTO. Will get applied to any new Session created by this object.

See Also:

setFlushModeName(java.lang.String), FLUSH_AUTO

getFlushMode

public int getFlushMode()

Return if a flush should be forced after executing the callback code.

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

flushIfNecessary

protected void flushIfNecessary(Session session,
                                boolean existingTransaction)
                         throws HibernateException

Flush the given Hibernate Session if necessary.

Parameters:

session - the current Hibernate Session

existingTransaction - if executing within an existing transaction

Throws:

HibernateException - in case of Hibernate flushing errors

convertHibernateAccessException

public DataAccessException convertHibernateAccessException(HibernateException ex)

Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy. Will automatically detect wrapped SQLExceptions and convert them accordingly.

The default implementation delegates to SessionFactoryUtils and convertJdbcAccessException. Can be overridden in subclasses.

Parameters:

ex - HibernateException that occured

Returns:

the corresponding DataAccessException instance

See Also:

convertJdbcAccessException(net.sf.hibernate.JDBCException), SessionFactoryUtils.convertHibernateAccessException(net.sf.hibernate.HibernateException)

convertJdbcAccessException

protected DataAccessException convertJdbcAccessException(JDBCException ex)

Convert the given JDBCException to an appropriate exception from the org.springframework.dao hierarchy. Can be overridden in subclasses.

Parameters:

ex - JDBCException that occured, wrapping a SQLException

Returns:

the corresponding DataAccessException instance

See Also:

setJdbcExceptionTranslator(org.springframework.jdbc.support.SQLExceptionTranslator)

convertJdbcAccessException

protected DataAccessException convertJdbcAccessException(SQLException ex)

Convert the given SQLException to an appropriate exception from the org.springframework.dao hierarchy. Can be overridden in subclasses.

Note that a direct SQLException can just occur when callback code performs direct JDBC access via Session.connection().

Parameters:

ex - the SQLException

Returns:

the corresponding DataAccessException instance

See Also:

setJdbcExceptionTranslator(org.springframework.jdbc.support.SQLExceptionTranslator), Session.connection()