[Springframework-developer] Getting the Configuration from a Hibernate *SessionFactoryBean

[Arnout E. <sp...@bz...>]

Hi,

The Hibernate *SessionFactoryBean contain a hibernate.cfg.Configuration, 
and in some cases it can be useful to have access to that object from 
the application. This isn't currently possible because the 
AbstractSessionFactoryBean returns the SessionFactory with getObject(), 
so the application only has access to the SessionFactory, not to the 
*SessionFactoryBean itself.

I wrote a simple workaround for that, allowing one to create an 
'ExposedSessionFactoryBean' in exactly the same way you'd normally make 
e.g. an AnnotationSessionFactoryBean:

public interface ExposedSessionFactoryBean {
    Configuration getHibernateConfiguration();
   
    SessionFactory getHibernateSessionFactory();
}

Implementation (for AnnotationSessionFactoryBeans):

public class ExposedAnnotationSessionFactoryBeanImpl extends
        AnnotationSessionFactoryBean
        implements ExposedSessionFactoryBean {

    /** Work around getConfiguration being protected final */
    public Configuration getHibernateConfiguration()
    {
        return getConfiguration();
    }
   
    /** Work around getSessionFactory being protected final */
    public SessionFactory getHibernateSessionFactory()
    {
        return getSessionFactory();
    }
   
    /** 'expose' ourselves instead of returning the SessionFactory */
    @Override
    public Object getObject() {
        return this;
    }

    /** 'expose' ourselves instead of returning the SessionFactory */
    @Override
    public Class getObjectType() {
        return getClass();
    }
}

With getHibernateSessionFactory(), a simple 'glue' bean can be written 
which takes the ExposedSessionFactoryBean and yields the SessionFactory, 
just like a normal *SessionFactoryBean would do:

public class SessionFactoryGetter implements FactoryBean {
    private ExposedSessionFactoryBean sessionFactoryBean;

    public ExposedSessionFactoryBean getSessionFactoryBean() {
        return sessionFactoryBean;
    }

    /** inject */
    public void setSessionFactoryBean(ExposedSessionFactoryBean 
sessionFactoryBean) {
        this.sessionFactoryBean = sessionFactoryBean;
    }

    /** fetch the SessionFactory from the ExposedSessionFactoryBean */
    public Object getObject() {
        return sessionFactoryBean.getHibernateSessionFactory();
    }

    /** publish the type of the sessionfactory */
    public Class getObjectType() {
        // this may be called before the sessionFactoryBean is injected, 
so we just
        return SessionFactory.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

This way, the applicationContext can remain reasonably clean: the 
exposedHibernateSessionFactory is configured exactly as you'd normally 
configure you hibernateSessionFactory:

<bean id="exposedHibernateSessionFactory" 
class="nl.topicuszorg.somepackage.ExposedAnnotationSessionFactoryBeanImpl">
        <property name="configLocation">
            <value>classpath:hibernate.cfg.xml</value>
        </property>
       <!-- more config here -->
    </bean>
   
And the hibernateSessionFactory is created from that 
exposedHibernateSessionFactory:

    <bean id="hibernateSessionFactory" 
class="nl.topicuszorg.hibernate.spring.orm.SessionFactoryGetter">
        <property name="sessionFactoryBean" 
ref="exposedHibernateSessionFactory"/>
    </bean>
   
This seems useful to me, and I'd like to make it more widely available.

Does this solution make sense technically? Are there neater ways to 
achieve this? If this seems all-right, I suppose I should prepare it as 
a patch against spring CVS HEAD and submit it to JIRA?


Regards,

Arnout