mojavelinux.com: Open Source Advocacy

Putting Entities to Rest with Groovy, Hibernate, and JPA

May 09, 2007

I mentioned in my previous entry about how I am totally sold on Groovy. I immediately went off and converted a couple of shell scripts that I use daily into Groovy scripts. I was pleasantly surprised by the CliBuilder for processing command-line arguments, but that is another story. What I am really excited about is what I was able to do next. While perusing Java Persistence with Hibernate, I started thinking about how Groovy might make object-relational persistence easier. I tend to dread working with Hibernate or JPA just because it takes a while to get it all setup, usually requiring the formal step of setting up a project in Eclipse.

That is where our story begins. The challenge: How hard is it to use Groovy to persist an entity class? The answer: Amazingly simple. So simple, in fact, that there is almost no reason to access the database any other way (unless you are a database purist and then you have your reasons). For me, I prefer the Hibernate or JPA route, if I can take it.

There exist a couple of other blog entries on this topic, but I promise you that I have an exciting conclusion. Let's get started.

Step 0. Groovy 1.1

You will need to be using Groovy 1.1, which has annotation support, to run these examples. At the time of writing this version is still in beta, but I have had no problems with it.

Step 1. Get the JARs

Easily the most annoying part of working with any library is having to aggregate all of the dependencies. Eventually we are going to have a clean, universal solution for this problem. Until then, Groovy helps to hide some of the nastiness. If you use Maven 2, which I happen to recommend, you will likely have most of these JARs already sitting in your local repository. Copy the list of JARs, shown below, to the ~/.groovy/lib/ folder. I have included both Hibernate and JPA JARs just so that I don't have to do this step twice. I went with MySQL for this example. If you would like to use another database, then you will need to include the appropriate JDBC driver and change the connection strings in the examples to suit that database.

• antlr-2.7.6.jar
• cglib-nodep-2.1_2.jar (fix incompatibility with Groovy asm library)
• commons-collections-3.2.jar
• commons-httpclient-2.0.2.jar
• commons-logging-1.1.jar
• dom4j-1.6.1.jar
• geronimo-j2ee_1.4_spec-1.1.jar (JTA: Java Transaction API)
• hibernate-3.2.1.ga.jar
• hibernate-annotations-3.2.1.ga.jar
• hibernate-entitymanager-3.2.1.ga.jar (Hibernate JPA)
• jboss-archive-browsing-5.0.0alpha-200607201-119.jar (Hibernate JPA)
• mysql-connector-java-5.0.5.jar
• persistence-api-1.0.jar

Please note that any JTA implementation will work. I just happen to use the Geronimo implementation since it is available in the public Maven 2 repository.

Step 2. Create an Entity class

So that I make no assumptions about existing tables, I am going to create a new entity class that will generate a table automatically. If you already have a table that you would like to use, then create an appropriate entity for it.

import javax.persistence.*

@Entity
@Table(name="contact")
class Contact implements Serializable {
    @Id @GeneratedValue
    Long id

    String name

    String email
}

Step 3. Create a SessionFactory or PersistentUnit configuration

Depending on whether you are going to do a Hibernate SessionFactory or a JPA PersistenceUnit, you will either create a hibernate.cfg.xml configuration or a META-INF/persistence.xml configuration. I will include both below. Choose the one appropriate for your choice of implementation. I will stick with the ordering of Hibernate snippets followed by JPA snippets.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/database</property>
        <property name="hibernate.connection.username">username</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.hbm2ddl.auto">create</property>
        <mapping class="Contact"/>
    </session-factory>
</hibernate-configuration>

or

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
    version="1.0">
    <persistence-unit name="default" transaction-type="RESOURCE_LOCAL">
        <class>Contact</class>
        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/database" />
            <property name="hibernate.connection.username" value="username" />
            <property name="hibernate.connection.password" value="password" />
            <property name="hibernate.hbm2ddl.auto" value="create" />
        </properties>
    </persistence-unit>
</persistence>

Step 4. Startup a session and do persistence operations

In this step, we are going to do everything in one script, including starting up the Hibernate SessionFactory or JPA PersistenceUnit and then executing some persistence operations.

import org.hibernate.*
import org.hibernate.cfg.*

sf = new AnnotationConfiguration().configure().buildSessionFactory()
sess = sf.openSession()
tx = sess.beginTransaction()
sess.createQuery("delete Contact").executeUpdate()
sess.save new Contact(name: 'Dan Allen', email: 'dallen@example.com')
tx.commit()
sess.close()
sf.close()

or

import javax.persistence.*

emf = Persistence.createEntityManagerFactory("default")
em = emf.createEntityManager()
em.getTransaction().begin()
em.createQuery("delete Contact").executeUpdate()
em.persist new Contact(name: 'Dan Allen', email: 'dallen@example.com')
em.getTransaction().commit()
em.close()
emf.close()

Step 5. Get groovy and create a template

Now we are going to take a pragmatic approach by creating a reusable template, which we can use to wrap the persistence operations. That way, it isn't necessary to do all the nasty work of starting up the persistence engine each time we write a script (even though it is still only a couple of lines). I call these two classes HibernateTemplate and JPATemplate respectively. They use an anonymous code block argument to a method that will execute the operations within a persistence session.

import org.hibernate.cfg.*
import org.hibernate.*

class HibernateTemplate {

    SessionFactory sf

    Session sess

    HibernateTemplate(config) {
        if (!config) config = "/hibernate.cfg.xml"
        sf = new AnnotationConfiguration().configure(config).buildSessionFactory()
    }

    void doInSession(c, shutdown) {
        sess = sf.openSession()
        def tx = sess.beginTransaction()
        c(sess)
        tx.commit()
        sess.close()
        if (shutdown) shutdown()
    }

    void shutdown() {
        sf.close()
    }
}

or

import javax.persistence.*

class JpaTemplate {

    EntityManagerFactory emf

    EntityManager em

    JpaTemplate(pu) {
        if (!pu) pu = "default"
        emf = Persistence.createEntityManagerFactory(pu)
    }

    void doInEntityManager(c, shutdown) {
        em = emf.createEntityManager()
        em.getTransaction().begin()
        c(em)
        em.getTransaction().commit()
        em.close()
        if (shutdown) shutdown()
    }

    void shutdown() {
        emf.close()
    }
}

Step 6. Take advantage of the templates

Now I will take the code from Step 4 and rewrite it using the template objects.

new HibernateTemplate().doInSession({ sess ->
    sess.createQuery("delete Contact").executeUpdate()
    sess.save new Contact(name:'Dan Allen', email: 'dallen@example.com')
}, true)

or

new JpaTemplate().doInEntityManager({ em ->
    em.createQuery("delete Contact").executeUpdate()
    em.persist new Contact(name:'Dan Allen', email: 'dallen@example.com')
}, true)

Look at that! I am using 4 lines of code to clean out the table and persist an entity!! Now that is groovy! If that doesn't get you excited about Groovy, then I don't know what will.

Posted at 06:49 PM in Java | Permalink