Hi!
I just looked into this today, and I wonder why we should set the EntityInterceptor on LocalSessionFactoryObject. Sure you can specify an interceptor to the underlying Configuration instance in LocalSessionFactoryObject which produces the session factory, but the produced session factory never exposes the interceptor. So I guess we could just forget LocalSessionFactoryObject then.
In my case, my DAOs inherit from HibernateDaoSupport and the default usage is to provide the DAOs with the session factory. Then, HibernateDaoSupport will always create a default HibernateTemplate, even if one already exists, the existing hibernate template will be replaced by the new default one! This means that the created HibernateTemplate will never reference my entity interceptor. My option is then to create my own HibernateTemplate pass it to my DAOs along with the session factory and at the moment I have to make sure that the template is passed in to HibernateDaoSupport after the ISessionFactory instance has been set so that I can replace the auto-produced template.
Okay, I guess I could do that. To make things easier, I could then just make my DAOs take the HibernateTemplate as ctor arg and then pass it to the base class (HibernateDaoSupport):
/// <summary>
/// An abstract class implementing generic DAO interface which will be used as an ancestor for all
/// DAO objects.
/// </summary>
public abstract class GenericDAO<KEY> : HibernateDaoSupport
{
/// <summary>
/// Constructor initializing the DAO with the configured template holding the
/// session factory object and entity interceptor.
/// </summary>
/// <param name="hibernateTemplate">The configured hibernate template</param>
protected GenericDAO(HibernateTemplate hibernateTemplate)
{
SessionFactory = hibernateTemplate.SessionFactory;
HibernateTemplate = hibernateTemplate;
}
The relevant parts of the configuration would then look like:
....
<object id="EntityInterceptor" type="Viz.Core.Persistence.nHibernate.Interceptors.Entit yInterceptor, Viz.Core.Persistence"/>
<!-- Hibernate Transaction Manager-->
<object id="hibernateTransactionManager" type="Spring.Data.NHibernate.HibernateTransactionManager , Spring.Data.NHibernate12">
<property name="DbProvider" ref="DbProviderRef"/>
<property name="SessionFactory" ref="SessionFactory"/>
<property name="EntityInterceptor" ref="EntityInterceptor"/>
</object>
<object id="hibernateTemplate" type="Spring.Data.NHibernate.HibernateTemplate, Spring.Data.NHibernate12">
<property name="SessionFactory" ref="SessionFactory"/>
<property name="QueryCacheRegion" value="Hibernate.Query"/>
<property name="CacheQueries" value="true"/>
<property name="EntityInterceptor" ref="EntityInterceptor"/>
</object>
<!-- DAO with NHibernate support by adding the SessionFactory -->
<object id="UserDAO" type="Viz.Core.Persistence.nHibernate.Dao.UserDAO, Viz.Core.Persistence">
<constructor-arg name="hibernateTemplate" ref="hibernateTemplate" />
</object>
....
Okay, if you are in a hurry (as I am) then this will solve your problem and make your interceptor do some interception! At least it worked for me ;)
For a more robust fix, I guess we could make some minor changes to the HibernateDaoSupport class. For instance, HibernateDaoSupport could take HibernateTemplate as input instead of an instance of ISessionFactory. This would make it explicit that the HibernateDaoSupprt class actually needs a hibernate template instance, and that you as a consumer of that class have to provide it! The session factory instance can always be derived from the hibernate template, so we do not worry about that (actually, that is what the current HibernateDaoSupport does once the session factory object has been passed into the dao support class, for details see the code listing below).
Other changes that must be done is to fix the SessionFactory property (or decide if it should be removed altogether) on HibernateDaoSupport, so that it never creates it's own HibernateTemplate, or at least not if an instance of the template already exists:
HibernateDaoSupport's SessionFactory property:
....
/// <summary>
/// Gets or sets the session factory to be used by this DAO.
/// Will automatically create a HibernateTemplate for the given SessionFactory.
/// </summary>
/// <value>The session factory.</value>
public ISessionFactory SessionFactory
{
get
{
return (this.hibernateTemplate != null ? this.hibernateTemplate.SessionFactory : null);
}
set
{
// The commented out lines below should be included:
// if(null == hibernateTemplate)
hibernateTemplate = CreateHibernateTemplate(value);
// else hibernateTemplate.SessionFactory = value;
}
}
...
I can see the usage where you just want to use a plain HibernateTemplate and the convenience of just getting it without any configuration by just setting the SessionFactory. In that case, at least the SessionFactory setter should be changed. What do you think?
Cheers,
Steinar.