Spring Data JPA sample project

In previous post I showed how to setup a sample project with JPA and Hibernate.
Even though it wasn't difficult, there was a main disadvantage - we need to do a lot of coding around our DAO objects even if we want only simple operations.
Spring Data JPA helps us reduce data access coding.

Let's start with defining dependencies:

	<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-jpa</artifactId>
	<version>1.1.0.RELEASE</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>3.2.0.RELEASE</version>
	</dependency>
	<dependency>
	<groupId>org.hibernate</groupId>
	<artifactId>hibernate-entitymanager</artifactId>
	<version>4.1.9.Final</version>
	</dependency>
	<dependency>
	<groupId>org.hsqldb</groupId>
	<artifactId>hsqldb</artifactId>
	<version>2.2.9</version>
	</dependency>
	<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.11</version>
	<scope>test</scope>
	</dependency>
	<dependency>
	<groupId>org.hamcrest</groupId>
	<artifactId>hamcrest-all</artifactId>
	<version>1.3</version>
	<scope>test</scope>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-test</artifactId>
	<version>3.2.0.RELEASE</version>
	<scope>test</scope>
	</dependency>

view raw spring_data_jpa_dependencies.xml hosted with ❤ by GitHub

Compared to previous project there are more dependencies because of Spring. spring-test is needed to allow our test use the spring context. And this time we're going o use HSQLDB.

pesistence.xml  is much smaller because the persistence configuration will be defined in spring context.

	<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_2_0.xsd" version="2.0">
	<persistence-unit name="springJpaPersistenceUnit" transaction-type="RESOURCE_LOCAL">
	<provider>org.hibernate.ejb.HibernatePersistence</provider>
	<class>pl.mjedynak.model.Person</class>
	<properties>
	<property name="hibernate.hbm2ddl.auto" value="create"/>
	</properties>
	</persistence-unit>
	</persistence>

view raw persistence.xml hosted with ❤ by GitHub

Please note that Hibernate is still the persistence provider. The Person class is exactly the same as before.

The context is defined as:

	<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:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd
	http://www.springframework.org/schema/data/jpa
	http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
	<context:component-scan base-package="pl.mjedynak"/>
	<jpa:repositories base-package="pl.mjedynak.repository"/>
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
	<property name="url" value="jdbc:hsqldb:file:sampledb"/>
	<property name="username" value="sa"/>
	<property name="password" value=""/>
	</bean>
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
	<property name="dataSource" ref="dataSource"/>
	<property name="persistenceXmlLocation" value="persistence.xml"/>
	<property name="persistenceUnitName" value="springJpaPersistenceUnit"/>
	</bean>
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
	<property name="entityManagerFactory" ref="entityManagerFactory"/>
	</bean>
	</beans>

view raw spring-context.xml hosted with ❤ by GitHub

We need to specify dataSource, entityManagerFactory and transactionManager.
The pl.mjedynak package will be scanned by spring to do autowiring.
Spring Data JPA introduces the concept of repository which is higher level of abstraction than the DAO.
In our context we define a package with the repositories.

The only thing to do to be able to manage our Person class is to create an interface that will extend CrudRepository - it gives us basic operations like save, find, delete etc.

	public interface PersonRepository extends CrudRepository<Person, Long> {
	}

view raw PersonRepository.java hosted with ❤ by GitHub

We can of course expand it with more sophisticated methods if we want.

The integration test is almost the same as before, except it needs to use spring context.

	@RunWith(SpringJUnit4ClassRunner.class)
	@ContextConfiguration(locations = "classpath:spring-context.xml")
	public class PersonRepositoryIntegrationTest {
	@Autowired
	private PersonRepository personRepository;
	@Test
	public void shouldFindPreviouslySavedPerson() {
	// given
	Integer age = 22;
	String name = "Charlie";
	Person person = aPerson().
	withAge(age).
	withName(name).build();
	personRepository.save(person);
	// when
	List<Person> result = (List<Person>) personRepository.findAll();
	// then
	assertThat(result, hasSize(1));
	Person foundPerson = result.get(0);
	assertThat(foundPerson.getAge(), is(age));
	assertThat(foundPerson.getName(), is(name));
	}
	}

view raw PersonRepositoryIntegrationTest.java hosted with ❤ by GitHub

The whole project can be found at: https://github.com/mjedynak/spring-data-jpa-example