HibernateAccessor (Spring Framework API 2.1) - Spring Framework 2.1.0 API 文档英文版

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.hibernate3
Class HibernateAccessor

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

All Implemented Interfaces:: BeanFactoryAware, InitializingBean

Direct Known Subclasses:: HibernateInterceptor, HibernateTemplate, OpenSessionInViewInterceptor

public abstract class HibernateAccessor
extends Object
implements InitializingBean, BeanFactoryAware
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:: 1.2
Author:: Juergen Hoeller
See Also:: HibernateTemplate, HibernateInterceptor, setFlushMode(int)

Field Summary

static int FLUSH_ALWAYS
          Flushing before every query statement is rarely necessary.

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 FlushMode applyFlushMode(Session session, boolean existingTransaction)
          Apply the flush mode that's been specified for this accessor to the given Session.

DataAccessException convertHibernateAccessException(HibernateException ex)
          Convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.

protected DataAccessException convertJdbcAccessException(JDBCException ex, SQLExceptionTranslator translator)
          Convert the given Hibernate JDBCException to an appropriate exception from the org.springframework.dao hierarchy, using the given SQLExceptionTranslator.

protected DataAccessException convertJdbcAccessException(SQLException ex)
          Convert the given SQLException to an appropriate exception from the org.springframework.dao hierarchy.

protected void disableFilters(Session session)
          Disable the specified filters on the given Session.

protected void enableFilters(Session session)
          Enable the specified filters on the given Session.

protected void flushIfNecessary(Session session, boolean existingTransaction)
          Flush the given Hibernate Session if necessary.

protected SQLExceptionTranslator getDefaultJdbcExceptionTranslator()
          Obtain a default SQLExceptionTranslator, lazily creating it if necessary.

Interceptor getEntityInterceptor()
          Return the current Hibernate entity interceptor, or null if none.

String[] getFilterNames()
          Return the names of Hibernate filters to be activated, if any.

int getFlushMode()
          Return if a flush should be forced after executing the callback code.

SQLExceptionTranslator getJdbcExceptionTranslator()
          Return the JDBC exception translator for this instance, if any.

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(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 setFilterName(String filter)
          Set the name of a Hibernate filter to be activated for all Sessions that this accessor works with.

void setFilterNames(String[] filterNames)
          Set one or more names of Hibernate filters to be activated for all Sessions that this accessor works with.

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 Summary
`static int`	`FLUSH_ALWAYS` Flushing before every query statement is rarely necessary.
`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 FlushMode`	`applyFlushMode(Session session, boolean existingTransaction)` Apply the flush mode that's been specified for this accessor to the given Session.
`DataAccessException`	`convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
`protected DataAccessException`	`convertJdbcAccessException(JDBCException ex, SQLExceptionTranslator translator)` Convert the given Hibernate JDBCException to an appropriate exception from the `org.springframework.dao` hierarchy, using the given SQLExceptionTranslator.
`protected DataAccessException`	`convertJdbcAccessException(SQLException ex)` Convert the given SQLException to an appropriate exception from the `org.springframework.dao` hierarchy.
`protected void`	`disableFilters(Session session)` Disable the specified filters on the given Session.
`protected void`	`enableFilters(Session session)` Enable the specified filters on the given Session.
`protected void`	`flushIfNecessary(Session session, boolean existingTransaction)` Flush the given Hibernate Session if necessary.
`protected SQLExceptionTranslator`	`getDefaultJdbcExceptionTranslator()` Obtain a default SQLExceptionTranslator, lazily creating it if necessary.
`Interceptor`	`getEntityInterceptor()` Return the current Hibernate entity interceptor, or `null` if none.
`String[]`	`getFilterNames()` Return the names of Hibernate filters to be activated, if any.
`int`	`getFlushMode()` Return if a flush should be forced after executing the callback code.
`SQLExceptionTranslator`	`getJdbcExceptionTranslator()` Return the JDBC exception translator for this instance, if any.
`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(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`	`setFilterName(String filter)` Set the name of a Hibernate filter to be activated for all Sessions that this accessor works with.
`void`	`setFilterNames(String[] filterNames)` Set one or more names of Hibernate filters to be activated for all Sessions that this accessor works with.
`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.

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

FLUSH_ALWAYS

public static final int FLUSH_ALWAYS

Flushing before every query statement is rarely necessary. It is only available for special needs.

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

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

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(org.hibernate.Interceptor)

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

getEntityInterceptor

public 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(org.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 any SQLException root cause of a Hibernate JDBCException, overriding Hibernate's default SQLException translation (which is based on Hibernate's Dialect for a specific target database).

Parameters:: jdbcExceptionTranslator - the exception translator
See Also:: SQLException, JDBCException, SQLErrorCodeSQLExceptionTranslator, SQLStateSQLExceptionTranslator

getJdbcExceptionTranslator

public SQLExceptionTranslator getJdbcExceptionTranslator()

Return the JDBC exception translator for this instance, if any.

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.

setFilterName

public void setFilterName(String filter)

Set the name of a Hibernate filter to be activated for all Sessions that this accessor works with.

This filter will be enabled at the beginning of each operation and correspondingly disabled at the end of the operation. This will work for newly opened Sessions as well as for existing Sessions (for example, within a transaction).

See Also:: enableFilters(org.hibernate.Session), Session.enableFilter(String), LocalSessionFactoryBean.setFilterDefinitions(org.hibernate.engine.FilterDefinition[])

setFilterNames

public void setFilterNames(String[] filterNames)

Set one or more names of Hibernate filters to be activated for all Sessions that this accessor works with.

Each of those filters will be enabled at the beginning of each operation and correspondingly disabled at the end of the operation. This will work for newly opened Sessions as well as for existing Sessions (for example, within a transaction).

See Also:: enableFilters(org.hibernate.Session), Session.enableFilter(String), LocalSessionFactoryBean.setFilterDefinitions(org.hibernate.engine.FilterDefinition[])

getFilterNames

public String[] getFilterNames()

Return the names of Hibernate filters to be activated, if any.

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 FlushMode applyFlushMode(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(org.hibernate.FlushMode)

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 apply a specified SQLExceptionTranslator to a Hibernate JDBCException, else rely on Hibernate's default translation.

Parameters:: ex - HibernateException that occured
Returns:: a corresponding DataAccessException
See Also:: SessionFactoryUtils.convertHibernateAccessException(org.hibernate.HibernateException), setJdbcExceptionTranslator(org.springframework.jdbc.support.SQLExceptionTranslator)

convertJdbcAccessException

protected DataAccessException convertJdbcAccessException(JDBCException ex,
                                                         SQLExceptionTranslator translator)

Convert the given Hibernate JDBCException to an appropriate exception from the org.springframework.dao hierarchy, using the given SQLExceptionTranslator.

Parameters:: ex - Hibernate JDBCException that occured; translator - the SQLExceptionTranslator to use
Returns:: a corresponding DataAccessException

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

getDefaultJdbcExceptionTranslator

protected SQLExceptionTranslator getDefaultJdbcExceptionTranslator()

Obtain a default SQLExceptionTranslator, lazily creating it if necessary.

Creates a default SQLErrorCodeSQLExceptionTranslator for the SessionFactory's underlying DataSource.

enableFilters

protected void enableFilters(Session session)

Enable the specified filters on the given Session.

Parameters:: session - the current Hibernate Session
See Also:: setFilterNames(java.lang.String[]), Session.enableFilter(String)

disableFilters

protected void disableFilters(Session session)

Disable the specified filters on the given Session.

Parameters:: session - the current Hibernate Session
See Also:: setFilterNames(java.lang.String[]), Session.disableFilter(String)

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

HibernateAccessor (Spring Framework API 2.1) - Spring Framework 2.1.0 API 文档英文版

org.springframework.orm.hibernate3 Class HibernateAccessor

FLUSH_NEVER

FLUSH_AUTO

FLUSH_EAGER

FLUSH_COMMIT

FLUSH_ALWAYS

logger

HibernateAccessor

setSessionFactory

getSessionFactory

setEntityInterceptorBeanName

setEntityInterceptor

getEntityInterceptor

setJdbcExceptionTranslator

getJdbcExceptionTranslator

setFlushModeName

setFlushMode

getFlushMode

setFilterName

setFilterNames

getFilterNames

setBeanFactory

afterPropertiesSet

applyFlushMode

flushIfNecessary

convertHibernateAccessException

convertJdbcAccessException

convertJdbcAccessException

getDefaultJdbcExceptionTranslator

enableFilters

disableFilters

org.springframework.orm.hibernate3
Class HibernateAccessor