Spring & JPA with Hibernate and EclipseLink

This is to show how to setup JPA with Spring, using Hibernate and EclipseLink respectively. We are not talking about ORM, which is a separate topic. So I am going to use a simple POJO.

First, let's create a simple class:

package my.test;

public class Book
{
    public int bookId;
    public String bookName;
    public String category;
}

Here I don't have getter/setter, since I will have field access later. But in the real world, you may have to use getter/setter if there is any lazy loading.

Then we create a DAO interface:

package my.test;

public interface BookDao
{
    void save(Book book);

    Book update(Book book);

    void delete(Book book);

    Book findById(int bookId);
}

Next, we are going to create a JPA entity-mapping file. Alternatively, we could use annotations in Book class. but I don't like this approach since in my environment, the domain models are relatively very large in size. I don't want "pollution" of any underlying implementations. So here is the entity mapping:

<?xml version="1.0" encoding="UTF-8" ?>

<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm
                        http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
    version="2.0">

    <entity class="my.test.Book" access="FIELD">
        <table name="mytest_book"/>
        <attributes>
            <id name="bookId"><column name="book_id"/></id>
            <basic name="bookName"><column name="book_name"/></basic>
            <basic name="category"><column name="category"/></basic>
        </attributes>
    </entity>
</entity-mappings>

I saved this file as book.jpa.xml under package my.test.dao.jpa. Note in JPA, usually we use an orm.xml for entity mapping under META-INF directory. But spring saves me a headache, I can put them anywhere I want. For more info, check: http://wiki.eclipse.org/EclipseLink/Examples/JPA/EclipseLink-ORM.XML

Now let's create the DAO implementation, using spring. 

package my.test.dao.jpa;

import my.test.Book;
import my.test.BookDao;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

public class BookDaoJpaImpl implements BookDao
{
    @PersistenceContext
    private EntityManager em;

    public void save(Book book)
    {
        this.em.persist(book);
    }

    public Book update(Book book)
    {
        return this.em.merge(book);
    }

    public void delete(Book book)
    {
        this.em.remove(book);
    }

    public Book findById(int bookId)
    {
        return this.em.find(Book.class, bookId);
    }
}

Note that EntityManager is in general not thread safe, but this instance injected by Spring is thread safe since it will create a new transactional entity manager for each thread. Another note is that the annotation usage here is within the DAO implementation, it's not "polluting" my domain model.

Now we need to create the standard persistence.xml.

<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_2_0.xsd"
	version="2.0" xmlns="http://java.sun.com/xml/ns/persistence">

    <persistence-unit name="myPersistenceUnit" transaction-type="RESOURCE_LOCAL">
        <mapping-file>my/test/dao/jpa/book.jpa.xml</mapping-file>
    </persistence-unit>
</persistence>

I saved this file in persistence.xml under package my.dao.jpa. In standard JPA, this file has to be under META-INF in classpath. But Spring saves me another headache. I can put it anywhere I want.

Now, we need to create the spring xml to stitch everything together. 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <bean id="bookDao" class="my.test.dao.jpa.BookDaoJpaImpl"/>

    <!-- bean post-processor for JPA annotations -->
    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>

    <aop:config>
        <aop:pointcut id="bookDaoMethods" expression="execution(* my.test.dao.jpa.BookDaoJpaImpl.*(..))"/>
        <aop:advisor advice-ref="bookDaoTxAdvice" pointcut-ref="bookDaoMethods"/>
    </aop:config>

    <tx:advice id="bookDaoTxAdvice" transaction-manager="myTxManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <bean id="myTxManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="myEmf"/>
    </bean>   

    <bean id="mydataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxIdle" value="10"/>
        <property name="maxActive" value="100"/>
        <property name="maxWait" value="10000"/>
        <property name="testOnBorrow" value="true"/>
        <property name="testWhileIdle" value="true"/>
        <property name="timeBetweenEvictionRunsMillis" value="1200000"/>
        <property name="minEvictableIdleTimeMillis" value="1800000"/>
        <property name="numTestsPerEvictionRun" value="5"/>
        <property name="defaultAutoCommit" value="true"/>
    </bean>

    <context:property-placeholder location="classpath:my/test/dao/jpa/jdbc.properties"/>
</beans>

Here we define the DAO class, the transaction manager, and the datasource. The jdbc.properties is like this:

jdbc.driver=oracle.jdbc.OracleDriver
jdbc.url=jdbc:oracle:thin:@*****
jdbc.username=
jdbc.password=

So far we haven't define the EntityManagerFactory yet, since we still stays in JPA.

If we use Hibernate as the JPA implementation, the EntityManagerFactory is like this:

<bean id="myEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="myPersistenceUnit"/>
        <property name="dataSource" ref="mydataSource"/>
        <property name="persistenceXmlLocation" value="classpath:my/test/dao/jpa/persistence.xml"/>
        <property name="loadTimeWeaver">
            <bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
        </property>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!-- <property name="showSql" value="true"/> -->
                <property name="generateDdl" value="false"/>
                <property name="database" value="ORACLE"/>
                <property name="databasePlatform" value="org.hibernate.dialect.OracleDialect"/>
            </bean>
        </property>
    </bean>

The only thing specific to Hibernate is the jpaVendorAdapter entry. Also note here we specify the persistence.xml location. For more info on load time weaver, check: http://static.springsource.org/spring/docs/2.5.6/reference/orm.html#orm-jpa-setup-lcemfb and 

http://www.eclipse.org/aspectj/doc/released/devguide/ltw.html

If we use EclipseLink, then the above bean becomes:

<bean id="myEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="myPersistenceUnit"/>
        <property name="dataSource" ref="mydataSource"/>
        <property name="persistenceXmlLocation" value="classpath:my/test/dao/jpa/persistence.xml"/>
        <property name="loadTimeWeaver">        
            <bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
        </property>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter">
                <property name="generateDdl" value="false"/>
                <property name="database" value="ORACLE"/>
                <property name="databasePlatform" value="org.eclipse.persistence.platform.database.OraclePlatform"/>
            </bean>
        </property>
</bean>

For spring: we need to following jars: spring jars and commons-logging. We also need aspectjweaver.jar and aopalliance.jar

For hibernate: we need hibernate jar,  the jars in the required directory, and the jar in the jpa directory.

For eclipselink: we need eclipselink jar and standard persistence 2.0 jar.

and don't forget jdbc driver jar, I am just using oracle. I am also using commons dbcp and pool jars.

If you are using eclipselink, don't forget to use -javaagent: <spring instrument jar>. Hiberate doesn't need this switch.

And for jdbc/orm, don't forget the nice handy small tool: p6spy. It could print out full SQL statements without ? marks.

Here are some references:

Hibernate: http://www.hibernate.org/

EclipseLink: http://www.eclipse.org/eclipselink/

JPA: http://jcp.org/en/jsr/detail?id=317

P6spy: http://sourceforge.net/projects/p6spy/

SQLProfiler: http://sourceforge.net/projects/sqlprofiler/