Spring can simplify your Hibernate application. Spring’s Hibernate integration uses the same generic transaction infrastructure and DAO exception hierarchy that it uses for JDBC, JDO, iBATIS, and TopLink, making it easy to mix and match persistence methodologies if necessary.

There are two approaches to Spring’s Hibernate integration:

1. Inversion of Control with a HibernateTemplate and Callback
2. Extending HibernateDaoSupport and Applying an AOP Interceptor

The IoC/HibernateTemplate methodology feels a lot like the JdbcTemplate methodology described in the last section. For this example, I will show the HibernateDaoSupport/AOP Interceptor approach.

After you have written your standard Hibernate mappings, there basically three things that you need to do to use Spring’s HibernateDaoSupport to implement a DAO:

1. Configure the Hibernate SessionFactory
2. Extend your DAO Implementation from HibernateDaoSupport
3. Wire in Transaction Support with AOP

So let’s do another implementation of the WidgetDAO using Hibernate. First of all, here is our Hibernate XML mapping for the Widget class:

<?xml version=“1.0″?>
<!DOCTYPE hibernate-mapping SYSTEM
  “http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd”><hibernate-mapping package=“com.zabada.springrecipes.model”>
  <class name=“Widget” table=“WIDGETS”>
    <id name=“id” column=“WIDGET_ID” type=“long”>
      <generator class=“native”/></id>
    <property name=“name” column=“NAME” type=“string”/>
    <property name=“size” column=“SIZE” type=“int”/>
  </class>
</hibernate-mapping>

If you’ve used Hibernate before, there should be nothing tricky here since Widget is a trivial class (there are no collections or other classes to associate to). So now we can wire up the Hibernate SessionFactory

Here is an example Hibernate SessionFactory configured in Spring. You will be using this instead of the typical hibernate-config.xml. All we are doing here is telling Hibernate/Spring what our Hibernate mapping files are:

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="mappingResources">
    <list>

      <value>com/zabada/springrecipes/base/Widget.hbm.xml</value>
    </list>
  </property>
</bean>
If you have a hibernate.properties in your classpath, the Spring LocalSessionFactoryBean will use that file to configure the database connections, dialect and pooling. Alternatively, you can define a DataSource in Spring (any class that implements javax.sql.DataSource) and explicity set all of your Hibernate properties in the LocalSessionFactoryBean:

<bean id=“sessionFactory”
class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
  <property name=“mappingResources”>
    <list>
      <value>com/zabada/springrecipes/base/Widget.hbm.xml</value>
    </list></property>
  <property name=“hibernateProperties”>
    <props>
      <prop key=“hibernate.dialect”>
        org.hibernate.dialect.HSQLDialect
      </prop>
    </props></property>
  <property name=“dataSource”>
    <ref bean=“dataSource”/>
  </property>
</bean><bean id=“dataSource”
class=“org.springframework.jdbc.datasource.DriverManagerDataSource”><property name=“driverClassName”>
    <value>org.hsqldb.jdbcDriver</value>
  </property>
  <property name=“url”>
    <value>jdbc:hsqldb:mem:widgets</value></property>
  <property name=“username”><value>sa</value></property>
  <property name=“password”><value></value></property>
</bean>
 

The Spring HibernateDaoSupport class provides all kinds of convenience methods for working with Hibernate. Most of these are accessible via the HibernateTemplate object that this class exposes.

Please note that Hibernate 2 throws checked HibernateExceptions and Hibernate 3 throws runtime exceptions. I am using Hibernate 3 and am blowing off runtime exceptions that might be thrown, but it might be more appropriate to deal with these exceptions here (this is just a example, not prduction code!)

Anyway, here is our WidgetDAO implemented by extending HibernateDaoSupport:

public class WidgetDAOHibernateImpl
              extends HibernateDaoSupport
              implements WidgetDAO
{
  /**
   * Returns a java.util.List of all Widgets in the system.
   * @return
   */
  public Collection getWidgets()
  {
    return getHibernateTemplate().loadAll(Widget.class);
  }

  /**
   * Get a Widget Object given the id
   * @param id
   * @return
   */
  public Widget getWidgetById(Long id)
  {
    return (Widget)
            getHibernateTemplate().load(Widget.class, id);
  }

  /**
   * Save a Widget Object, if the given Widget
   * is not in the data store,it should insert it,
   * if it is in the data store, it should update it.
   * @param widget
   */
  public Widget saveWidget(Widget widget)
  {
    getHibernateTemplate().saveOrUpdate(widget);
    return widget;
  }
}
Now we wire up our DAO and weave in the HibernateInterceptor. This interceptor binds a new Hibernate Session to the thread before a method call, closing and removing it afterwards in case of any method outcome. If there already is a pre-bound Session, the interceptor simply participates in it. Note that the actual “widgetDAO” bean is defined as a proxy bean that really points to a bean called “widgetDaoTarget” which is where we wire up our actual implementation.

 <!– THE HIBERNATE INTERCEPTOR –>
<bean id=“hibernateInterceptor”
class=“org.springframework.orm.hibernate3.HibernateInterceptor”>
  <property name=“sessionFactory”><ref bean=“sessionFactory”/>
  </property>
</bean><bean id=“widgetDaoTarget”
class=“com.zabada.springrecipes.hibernate.WidgetDAOHibernateImpl”>
  <property name=“sessionFactory”>
    <ref bean=“sessionFactory”/></property>
</bean><bean id=“widgetDAO”
  class=“org.springframework.aop.framework.ProxyFactoryBean”>
  <property name=“proxyInterfaces”>
    <value>com.zabada.springrecipes.base.WidgetDAO</value>
  </property><property name=“interceptorNames”>
    <list>
      <value>hibernateInterceptor</value>
      <value>widgetDaoTarget</value>
    </list></property>
</bean>

Spring can simplify your Hibernate code. Transactions can be wired in with AOP services provided by Spring.

Note:

 Spring provides support for both Hibernate 2.1.x and 3.0. Hibernate 2.1.x is supported in the package org.springframework.orm.hibernate and Hibernate 3.0 is support in the package org.springframework.orm.hibernate3. Both of these packages contain almost identitical classes.

•   Spring Reference Manual – Hibernate Integration
• Data Access with Spring Framework by Juergen Hoeller
• OnJava: Wire Hibernate Transactions in Spring
• Expert One-on-One J2EE Development without EJB – Chapter 10: Persistence
• Spring in Action – Chapter 4 – Hitting the Database by Craig Walls and Ryan Breidenbach
• Pro Spring – Chapter 9 – Using Hibernate in Spring Applications by Rob Harrop and Jan Machacek