java.lang.Object | |
↳ | org.springframework.orm.hibernate3.HibernateAccessor |
Known Direct Subclasses |
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
.
Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
int | FLUSH_ALWAYS | Flushing before every query statement is rarely necessary. | |||||||||
int | FLUSH_AUTO | Automatic flushing is the default mode for a Hibernate Session. | |||||||||
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. | |||||||||
int | FLUSH_EAGER | Eager flushing leads to immediate synchronization with the database, even if in a transaction. | |||||||||
int | FLUSH_NEVER | Never flush is a good strategy for read-only units of work. |
Fields | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
logger | Logger available to subclasses |
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Invoked by a BeanFactory after it has set all bean properties supplied
(and satisfied BeanFactoryAware and ApplicationContextAware).
| |||||||||||
Convert the given HibernateException to an appropriate exception
from the
org.springframework.dao hierarchy. | |||||||||||
Return the current Hibernate entity interceptor, or
null if none. | |||||||||||
Return the names of Hibernate filters to be activated, if any.
| |||||||||||
Return if a flush should be forced after executing the callback code.
| |||||||||||
Return the JDBC exception translator for this instance, if any.
| |||||||||||
Return the Hibernate SessionFactory that should be used to create
Hibernate Sessions.
| |||||||||||
The bean factory just needs to be known for resolving entity interceptor
bean names.
| |||||||||||
Set a Hibernate entity interceptor that allows to inspect and change
property values before writing to and reading from the database.
| |||||||||||
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.
| |||||||||||
Set the name of a Hibernate filter to be activated for all
Sessions that this accessor works with.
| |||||||||||
Set one or more names of Hibernate filters to be activated for all
Sessions that this accessor works with.
| |||||||||||
Set the flush behavior to one of the constants in this class.
| |||||||||||
Set the flush behavior by the name of the respective constant
in this class, e.g.
| |||||||||||
Set the JDBC exception translator for this instance.
| |||||||||||
Set the Hibernate SessionFactory that should be used to create
Hibernate Sessions.
|
Protected Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Apply the flush mode that's been specified for this accessor
to the given Session.
| |||||||||||
Convert the given SQLException to an appropriate exception from the
org.springframework.dao hierarchy. | |||||||||||
Convert the given Hibernate JDBCException to an appropriate exception
from the
org.springframework.dao hierarchy, using the
given SQLExceptionTranslator. | |||||||||||
Disable the specified filters on the given Session.
| |||||||||||
Enable the specified filters on the given Session.
| |||||||||||
Flush the given Hibernate Session if necessary.
| |||||||||||
Obtain a default SQLExceptionTranslator, lazily creating it if necessary.
|
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
java.lang.Object
| |||||||||||
From interface
org.springframework.beans.factory.BeanFactoryAware
| |||||||||||
From interface
org.springframework.beans.factory.InitializingBean
|
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.
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.
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.
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:
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.
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.
Logger available to subclasses
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.
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.
ex | HibernateException that occured |
---|
Return the current Hibernate entity interceptor, or null
if none.
Resolves an entity interceptor bean name via the bean factory,
if necessary.
IllegalStateException | if bean name specified but no bean factory set |
---|---|
BeansException | if bean name resolution via the bean factory failed |
Return if a flush should be forced after executing the callback code.
Return the JDBC exception translator for this instance, if any.
Return the Hibernate SessionFactory that should be used to create Hibernate Sessions.
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.
beanFactory | owning BeanFactory (never null ).
The bean can immediately call methods on the factory. |
---|
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.
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.
entityInterceptorBeanName | the name of the entity interceptor in the bean factory |
---|
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).
setFilterDefinitions(FilterDefinition[])
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).
setFilterDefinitions(FilterDefinition[])
Set the flush behavior to one of the constants in this class. Default is FLUSH_AUTO.
Set the flush behavior by the name of the respective constant in this class, e.g. "FLUSH_AUTO". Default is "FLUSH_AUTO".
constantName | name of the constant |
---|
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).
jdbcExceptionTranslator | the exception translator |
---|
SQLException
SQLErrorCodeSQLExceptionTranslator
SQLStateSQLExceptionTranslator
Set the Hibernate SessionFactory that should be used to create Hibernate Sessions.
Apply the flush mode that's been specified for this accessor to the given Session.
session | the current Hibernate Session |
---|---|
existingTransaction | if executing within an existing transaction |
null
if nonesetFlushMode(int)
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()
.
ex | the SQLException |
---|
setJdbcExceptionTranslator(SQLExceptionTranslator)
Convert the given Hibernate JDBCException to an appropriate exception
from the org.springframework.dao
hierarchy, using the
given SQLExceptionTranslator.
ex | Hibernate JDBCException that occured |
---|---|
translator | the SQLExceptionTranslator to use |
Disable the specified filters on the given Session.
session | the current Hibernate Session |
---|
setFilterNames(String[])
Enable the specified filters on the given Session.
session | the current Hibernate Session |
---|
setFilterNames(String[])
Flush the given Hibernate Session if necessary.
session | the current Hibernate Session |
---|---|
existingTransaction | if executing within an existing transaction |
in case of Hibernate flushing errors | |
HibernateException |
Obtain a default SQLExceptionTranslator, lazily creating it if necessary.
Creates a default
SQLErrorCodeSQLExceptionTranslator
for the SessionFactory's underlying DataSource.