|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.springframework.orm.hibernate3.HibernateAccessor
public abstract class HibernateAccessor
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
.
HibernateTemplate
,
HibernateInterceptor
,
setFlushMode(int)
Field Summary | |
---|---|
private BeanFactory |
beanFactory
Just needed for entityInterceptorBeanName. |
private static Constants |
constants
Constants instance for HibernateAccessor |
private SQLExceptionTranslator |
defaultJdbcExceptionTranslator
|
private java.lang.Object |
entityInterceptor
|
private java.lang.String[] |
filterNames
|
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. |
private int |
flushMode
|
private SQLExceptionTranslator |
jdbcExceptionTranslator
|
protected Log |
logger
Logger available to subclasses |
private SessionFactory |
sessionFactory
|
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(java.sql.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. |
java.lang.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(java.lang.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(java.lang.String filter)
Set the name of a Hibernate filter to be activated for all Sessions that this accessor works with. |
void |
setFilterNames(java.lang.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(java.lang.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 |
---|
public static final int FLUSH_NEVER
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.
setFlushMode(int)
,
Constant Field Valuespublic static final int FLUSH_AUTO
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.
setFlushMode(int)
,
Constant Field Valuespublic static final int FLUSH_EAGER
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.
setFlushMode(int)
,
Constant Field Valuespublic static final int FLUSH_COMMIT
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.
setFlushMode(int)
,
Constant Field Valuespublic static final int FLUSH_ALWAYS
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.
setFlushMode(int)
,
Constant Field Valuesprivate static final Constants constants
protected final Log logger
private SessionFactory sessionFactory
private java.lang.Object entityInterceptor
private SQLExceptionTranslator jdbcExceptionTranslator
private SQLExceptionTranslator defaultJdbcExceptionTranslator
private int flushMode
private java.lang.String[] filterNames
private BeanFactory beanFactory
setEntityInterceptorBeanName(java.lang.String)
Constructor Detail |
---|
public HibernateAccessor()
Method Detail |
---|
public void setSessionFactory(SessionFactory sessionFactory)
public SessionFactory getSessionFactory()
public void setEntityInterceptorBeanName(java.lang.String entityInterceptorBeanName)
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 factorysetBeanFactory(org.springframework.beans.factory.BeanFactory)
,
setEntityInterceptor(Interceptor)
public void setEntityInterceptor(Interceptor entityInterceptor)
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.
setEntityInterceptorBeanName(java.lang.String)
,
LocalSessionFactoryBean.setEntityInterceptor(Interceptor)
,
HibernateTransactionManager.setEntityInterceptor(Interceptor)
public Interceptor getEntityInterceptor() throws java.lang.IllegalStateException, BeansException
null
if none.
Resolves an entity interceptor bean name via the bean factory,
if necessary.
java.lang.IllegalStateException
- if bean name specified but no bean factory set
BeansException
- if bean name resolution via the bean factory failedsetEntityInterceptor(Interceptor)
,
setEntityInterceptorBeanName(java.lang.String)
,
setBeanFactory(org.springframework.beans.factory.BeanFactory)
public void setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)
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 translatorSQLException
,
org.hibernate.JDBCException
,
SQLErrorCodeSQLExceptionTranslator
,
SQLStateSQLExceptionTranslator
public SQLExceptionTranslator getJdbcExceptionTranslator()
public void setFlushModeName(java.lang.String constantName)
constantName
- name of the constantsetFlushMode(int)
,
FLUSH_AUTO
public void setFlushMode(int flushMode)
setFlushModeName(java.lang.String)
,
FLUSH_AUTO
public int getFlushMode()
public void setFilterName(java.lang.String filter)
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).
#enableFilters(org.hibernate.Session)
,
org.hibernate.Session#enableFilter(String)
,
LocalSessionFactoryBean.setFilterDefinitions(FilterDefinition[])
public void setFilterNames(java.lang.String[] filterNames)
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).
#enableFilters(org.hibernate.Session)
,
org.hibernate.Session#enableFilter(String)
,
LocalSessionFactoryBean.setFilterDefinitions(FilterDefinition[])
public java.lang.String[] getFilterNames()
public void setBeanFactory(BeanFactory beanFactory)
setBeanFactory
in interface BeanFactoryAware
beanFactory
- owning BeanFactory (never null
).
The bean can immediately call methods on the factory.setEntityInterceptorBeanName(java.lang.String)
public void afterPropertiesSet()
InitializingBean
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.
afterPropertiesSet
in interface InitializingBean
protected FlushMode applyFlushMode(Session session, boolean existingTransaction)
session
- the current Hibernate SessionexistingTransaction
- if executing within an existing transaction
null
if nonesetFlushMode(int)
,
org.hibernate.Session#setFlushMode
protected void flushIfNecessary(Session session, boolean existingTransaction) throws HibernateException
session
- the current Hibernate SessionexistingTransaction
- if executing within an existing transaction
HibernateException
- in case of Hibernate flushing errorspublic DataAccessException convertHibernateAccessException(HibernateException ex)
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
SessionFactoryUtils.convertHibernateAccessException(HibernateException)
,
setJdbcExceptionTranslator(org.springframework.jdbc.support.SQLExceptionTranslator)
protected DataAccessException convertJdbcAccessException(JDBCException ex, SQLExceptionTranslator translator)
org.springframework.dao
hierarchy, using the
given SQLExceptionTranslator.
ex
- Hibernate JDBCException that occuredtranslator
- the SQLExceptionTranslator to use
protected DataAccessException convertJdbcAccessException(java.sql.SQLException ex)
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(org.springframework.jdbc.support.SQLExceptionTranslator)
,
org.hibernate.Session#connection()
protected SQLExceptionTranslator getDefaultJdbcExceptionTranslator()
Creates a default
SQLErrorCodeSQLExceptionTranslator
for the SessionFactory's underlying DataSource.
protected void enableFilters(Session session)
session
- the current Hibernate SessionsetFilterNames(java.lang.String[])
,
org.hibernate.Session#enableFilter(String)
protected void disableFilters(Session session)
session
- the current Hibernate SessionsetFilterNames(java.lang.String[])
,
org.hibernate.Session#disableFilter(String)
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |