Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.orm.hibernate
Class HibernateAccessor

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

All Implemented Interfaces:
  BeanFactoryAware, InitializingBean

Direct Known Subclasses:
  HibernateInterceptor, HibernateTemplate, OpenSessionInViewInterceptor

    public abstract class HibernateAccessor

extends Object
implements InitializingBean, BeanFactoryAware

Base class for `HibernateTemplate` and `HibernateInterceptor`, defining common properties such as 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_COMMIT` Flushing at commit only is intended for units of work where no intermediate flushing is desired, not even for find operations that might involve already modified instances.
`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` Logger available to subclasses

Constructor Summary
`HibernateAccessor()`

Method Summary
`void` | `afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
`protected net.sf.hibernate.FlushMode` | `applyFlushMode(net.sf.hibernate.Session session, boolean existingTransaction)` Apply the flush mode that's been specified for this accessor to the given Session.
`DataAccessException` | `convertHibernateAccessException(net.sf.hibernate.HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
`protected DataAccessException` | `convertJdbcAccessException(net.sf.hibernate.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(net.sf.hibernate.Session session, boolean existingTransaction)` Flush the given Hibernate Session if necessary.
`net.sf.hibernate.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.
`net.sf.hibernate.SessionFactory` | `getSessionFactory()` Return the Hibernate SessionFactory that should be used to create Hibernate Sessions.
`void` | `setBeanFactory(BeanFactory beanFactory)` The bean factory just needs to be known for resolving entity interceptor bean names.
`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` | `setEntityInterceptorBeanName(String entityInterceptorBeanName)` Set the bean name of 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(net.sf.hibernate.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.

  In case of an existing Session, FLUSH_NEVER will turn the flush mode to NEVER for the scope of the current operation, resetting the previous flush mode afterwards.

  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, and on certain find operations that might involve already modified instances, but not after each unit of work like with eager flushing.

  In case of an existing Session, FLUSH_AUTO will participate in the existing flush mode, not modifying it for the current operation. This in particular means that this setting will not modify an existing flush mode NEVER, in contrast to FLUSH_EAGER.

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

  In case of an existing Session, FLUSH_EAGER will turn the flush mode to AUTO for the scope of the current operation and issue a flush at the end, resetting the previous flush mode afterwards.

  See Also:
    `setFlushMode(int)`, Constant Field Values

### FLUSH_COMMIT

    public static final int FLUSH_COMMIT

  Flushing at commit only is intended for units of work where no intermediate flushing is desired, not even for find operations that might involve already modified instances.

  In case of an existing Session, FLUSH_COMMIT will turn the flush mode to COMMIT for the scope of the current operation, resetting the previous flush mode afterwards. The only exception is an existing flush mode NEVER, which will not be modified through this setting.

  See Also:
    `setFlushMode(int)`, Constant Field Values

### logger

    protected final Log logger

  Logger available to subclasses

Constructor Detail

### HibernateAccessor

    public HibernateAccessor()

Method Detail

### setSessionFactory

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

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

### getSessionFactory

    public net.sf.hibernate.SessionFactory getSessionFactory()

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

### setEntityInterceptorBeanName

    public void setEntityInterceptorBeanName(String entityInterceptorBeanName)

  Set the bean name of 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.

  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 in the bean factory
  See Also:
    `setBeanFactory(org.springframework.beans.factory.BeanFactory)`, `setEntityInterceptor(net.sf.hibernate.Interceptor)`

### 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 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:
    `setEntityInterceptorBeanName(java.lang.String)`, `LocalSessionFactoryBean.setEntityInterceptor(net.sf.hibernate.Interceptor)`, `HibernateTransactionManager.setEntityInterceptor(net.sf.hibernate.Interceptor)`

### getEntityInterceptor

    public net.sf.hibernate.Interceptor getEntityInterceptor()
                                                      throws IllegalStateException,
                                                             BeansException

  Return the current Hibernate entity interceptor, or `null` if none. Resolves an entity interceptor bean name via the bean factory, if necessary.

  Throws:
    `IllegalStateException` - if bean name specified but no bean factory set
    `BeansException` - if bean name resolution via the bean factory failed
  See Also:
    `setEntityInterceptor(net.sf.hibernate.Interceptor)`, `setEntityInterceptorBeanName(java.lang.String)`, `setBeanFactory(org.springframework.beans.factory.BeanFactory)`

### 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".

  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.

  See Also:
    `setFlushModeName(java.lang.String)`, `FLUSH_AUTO`

### getFlushMode

    public int getFlushMode()

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

### setBeanFactory

    public void setBeanFactory(BeanFactory beanFactory)

  The bean factory just needs to be known for resolving entity interceptor bean names. It does not need to be set for any other mode of operation.

  Specified by:
    `setBeanFactory` in interface `BeanFactoryAware`
  Parameters:
    `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
  See Also:
    `setEntityInterceptorBeanName(java.lang.String)`

### 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`

### applyFlushMode

    protected net.sf.hibernate.FlushMode applyFlushMode(net.sf.hibernate.Session session,
                                                        boolean existingTransaction)

  Apply the flush mode that's been specified for this accessor to the given Session.

  Parameters:
    `session` - the current Hibernate Session
    `existingTransaction` - if executing within an existing transaction
  Returns:
    the previous flush mode to restore after the operation, or `null` if none
  See Also:
    `setFlushMode(int)`, `Session.setFlushMode(net.sf.hibernate.FlushMode)`

### flushIfNecessary

    protected void flushIfNecessary(net.sf.hibernate.Session session,
                                    boolean existingTransaction)
                             throws net.sf.hibernate.HibernateException

  Flush the given Hibernate Session if necessary.

  Parameters:
    `session` - the current Hibernate Session
    `existingTransaction` - if executing within an existing transaction
  Throws:
    `net.sf.hibernate.HibernateException` - in case of Hibernate flushing errors

### convertHibernateAccessException

    public DataAccessException convertHibernateAccessException(net.sf.hibernate.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(net.sf.hibernate.JDBCException)`. 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(net.sf.hibernate.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()`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2007 The Spring Framework.