Easy Data with Spring-Data JPA

Miya W. Longwe, Tech Lead, Staples Inc.January 07, 2014

Java Meetup Group, Cambridge, MA , USA

Agenda Java DB Access Ordeal

Enter Spring-Data

Spring-Data JPA Features

Code Demo

Q and A

Java DB AccessThe Developer’s Holy Pilgrim!

Application Domain Domain driven design has become a

ubiquitous approach to tackle complex problem domains and build a rich object model.

Implementing a data access layer of an application has been cumbersome for quite a while.

Too much boilerplate code has to be written.

Code to execute simple queries as well as perform pagination, auditing, etc

Java DB Access – AccessorInterface

public interface CustomerService {Customer findById(Long id);Customer save(Customer customer);List<Customer> findAll();List<Customer> findAll(int page, int pageSize);...}

Java DB Access –The Boilerplate Code

/** * Plain JPA implementation of {@link CustomerService}. * * @author Miya W Longwe */@Repository@Transactional(readOnly = true)public class CustomerServiceImpl implements CustomerService {

@PersistenceContextprivate EntityManager em;

@Overridepublic Customer findById(Long id) {

return em.find(Customer.class, id);}

@Overridepublic List<Customer> findAll() {

return em.createQuery("select c from Customer c", Customer.class).getResultList();

}……

}

Java DB Access – The Story● JPA handles mechanics of ORM● The catch:– You are responsible for accessor boilerplate code● Using direct JDBC?– More boilerplate code (think DAO layer)● What about Spring support?– Makes things better (JdbcTemplate)– Spring-Data eases the pain further

Spring-Data to the Rescue!

Spring-Data Uses the Repository abstraction for

data access

Automation of data access boilerplate code

Reduces level of efforts for accessor code

Support for multiple data stores including– JPA– Key-Value, column, document, graph data stores(Redis, Mongo, Neo4j, HBase)– Hadoop / HDFS – Others

Spring-Data JPA Workflow Define an Entity Class

Define a Repository interface with data accessor methods

Then see you gator!

Define Your Entity

/** * An entity class which contains the information of a single person. * @author Miya W. Longwe */@Entity@Table(name = "persons")public class Person { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @Column(name = "creation_time", nullable = false) private Date creationTime; @Column(name = "first_name", nullable = false) private String firstName;

@Column(name = "last_name", nullable = false) private String lastName; @Column(name = "modification_time", nullable = false) private Date modificationTime; ...}

Define The Repository Interface

You provide a Java interface

– Attach an entity type along with key type

– CRUD/data accessor method signatures

Spring-Data can automatically derive proper JPQL

In simpler cases, no additional code required

Queries are derived from method signatures

Repository Interface

* Specifies methods used to obtain and modify person related information * which is stored in the database. * @author Miya W. Longwe */public interface PersonRepository extends JpaRepository<Person, Long> {}

No More Boilerplate Code It goes away (sort of) *

Spring-Data framework derives and attaches JPQL (or specified query) at load-time

Spring-Data Features

Provided Repositories Spring-Data JPA provides two

repositories

CrudRepository– Long list of standard CRUD operations provided– findOne(), findAll(), save(), delete(), exists(), etc

PagingAndSortingRepository

– Derived from CrudRepository

– Provides paginated repository access methods

Configure Spring Framework Specify your repository locations for

scanning

Spring will create proxy instances for repositories

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http:/www.springframework.org/schema/beans" xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"><mvc:resources mapping="/static/**" location="/static/"/>

<mvc:default-servlet-handler/>

<!-- Configures Spring Data JPA and sets the base package of my DAOs. --> <jpa:repositories base-package="com.meetup.easydata.spring.datajpa.repository"/></beans>

Spring-Data Query Generation Derived from method signatures

Parses method names for attributes and keywords

Uses method parameters as query params

public interface UserRepository extends CrudRepository<User, Long> {List<Customer> findByEmailAddressAndLastname(String emailAddress, String lastname);}

Select c from Customer where c.emailAddress = ?1 and c.lastName = ?2

Spring-DataMethod Name-to-JPQL Mapping

Method Name Generated JPQL

findByXxxAndYyy(aaa, bbb)

... where t.xxx = ?1 and t.yyy = ?2

findByXxxOrYyy(aaa, bbb)

... where t.xxx = ?1 or t.yyy = ?2

findByXxxStartingWith(aaa)

('%' appended to param value)

findByXxxNot(aaa) ... where t.xxx <> ?1

findByXxxIn(Collection<E>aaa)

...where t.xxx in ?1

---and many more!

Spring-DataFurther Property Parsing Features

-Traversal can reach into nested properties -Will do best effort using camelCase-You can delineate properties using “_”

}@Entitypublic class User <Long> {private ZiCode zicode;--}

}public interface UserRepository extends CrudRepository<User, Long>{...User findByAddress_ZipCode(ZipCode zipCode);

@Query – Use Your Own Query

• You don't like the derived query or want to do

something fancier?● Use @Query notation to provide your own● Support both JPQL or native SQL● Still provides automatic proxy implementationpublic interface UserRepository extends

CrudRepository<User, Long>{...@Query("select u from User u where u.firstname = ?1")List<User> findByFirstname(String firstname);@Query(value="SELECT FROM USERS WHERE EMAIL_ADDRESS = ?1" nativeQuery=true)User findByEmailAddress(String email);

...

@Query – Named Params

• Spring-Data JPA will use position for parameter binding• You can also use named params instead

interface UserRepository extends CrudRepository<User, Long>{...@Query("select u from User u where u.firstname = :name or u.lastname = :name")List<User> findByFirstnameOrLastname(@Param("name") String name);...}

Result Pagination

• Seamlessly provides support for result set pagination via Pageable Interface

• Define repository method with Pageable• Call method with PageRequest class (or define your

own)

public interface ProductRepository extends CrudRepository<User, Long>{...Page<Product> findAll(Pageable pageable);...}

class ProductService {Pageable pageable = new PageRequest(1, 20);Page<Product> page = repository.findByDescriptionContaining(pageable);}

Custom Repositories

• When Spring-Data JPA derived queries are not• enough or you need additional logic• Provide your own repository implementation• A bean that lives in Spring Context

interface UserRepositoryCustom {List<User> myCustomBatchOperation();}

class UserRepositoryImpl implements UserRepositoryCustom {@PersistenceContextprivate EntityManager em;public List<User> myCustomBatchOperation() {CriteriaQuery<User> criteriaQuery = em.getCriteriaBuilder().createQuery(User.class);return em.createQuery(criteriaQuery).getResultList();}}

Transaction Support

• Repository classes are transactional by default• Reads are made readOnly• Other methods are @Transactional by default• Ability to override by providing your own@Transactional demarcation

public interface UserRepository extends CrudRepository<User, Long>{...@Transactional(timeout=10)@Modifying@Query("update User u set u.firstname = ?1 where u.lastname = ?2")User fixFirstNameByLastName(String firstname, String lastname);...}

Code Demo