The previous part of my Spring Data JPA tutorial described how you can sort query results with Spring Data JPA. This blog entry will describe how you can paginate the query results by using Spring Data JPA. In order to demonstrate the pagination support of Spring Data JPA, I will add two new requirements for my example application:
- The person search results should be paginated.
- The maximum number of persons shown on a single search result page is five.
I will explain the pagination support of Spring Data JPA and my example implementation in following Sections.
Pagination with Spring Data JPA
The key of component of the Spring Data JPA pagination support is the Pageable interface which is implemented by PageRequest class. You can get a specific page of your query results by following these steps:
- Create an instance of the PageRequest class.
- Pass the created object as a parameter to the correct repository method.
The available repository methods are described in following:
- If you want to simply paginate all objects found from the database, you should use the public Page<T> findAll(Pageable pageable) method of the JpaRepository<T> interface.
- If you are building your queries by using the query generation from method name strategy, you can paginate the query results by passing the Pageable instance as a parameter of your method. Check the Spring Data JPA reference manual for more details (1.3.2.3 Special Parameter Handling).
- If you are using the JPA criteria API for building your query, you should use the public Page<T> findAll(Specification specification, Pageable pageable) method of the JpaSpecificationExecutor<T> interface.
- If you are building your queries with Querydsl, you should use the public Page<T> findAll(Predicate predicate, Pageable pageable) method of the QueryDslPredicateExercutor<T> interface.
After you have obtained the requested page, you can get a list of entities by calling the getContent() method of the Page<T> interface.
Enough with the theory, lets take a look how the given requirements can be implemented with JPA criteria API.
Adding Pagination to Person Search Results
The given requirements can be implemented with JPA criteria API by following these steps:
- Obtain the wanted page number.
- Create the needed Specification instance.
- Create the instance of a PageRequest class.
- Pass the created Specification and PageRequest objects to the person repository.
First, I modified the search() method of the PersonService interface. In order to obtain the wanted page from the database, the repository needs to know what page it should be looking for. Thus, I had to add a new parameter to the search() method. The name of this parameter is pageIndex and it specifies the index of the wanted page. The declaration of the new search() methods is given in following:
/**
* Searches persons for a given page by using the given search term.
* @param searchTerm
* @param pageIndex
* @return A list of persons whose last name begins with the given search term and who are belonging to the given page.
* If no persons is found, this method returns an empty list. This search is case insensitive.
*/
public List<Person> search(String searchTerm, int pageIndex);
}
Second, since I am using the JPA criteria API for building the actual query, the RepositoryPersonService will obtain the needed specification by calling the static lastNameIsLike() method of PersonSpecifications class. The source code of the PersonSpecifications class is given in following:
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
public class PersonSpecifications {
public static Specification<Person> lastNameIsLike(final String searchTerm) {
return new Specification<Person>() {
@Override
public Predicate toPredicate(Root<Person> personRoot, CriteriaQuery<?> query, CriteriaBuilder cb) {
String likePattern = getLikePattern(searchTerm);
return cb.like(cb.lower(personRoot.<String>get(Person_.lastName)), likePattern);
}
private String getLikePattern(final String searchTerm) {
StringBuilder pattern = new StringBuilder();
pattern.append(searchTerm.toLowerCase());
pattern.append("%");
return pattern.toString();
}
};
}
}
Third, I need to create an instance of a PageRequest class and pass this instance to the PersonRepository. I created a private method called constructPageSpecification() to the RepositoryPersonService. This method simply creates a new instance of the PageRequest object and returns the created instance. The search method obtains the PageRequest instance by calling the constructPageSpecification() method.
The last step is to pass the created objects forward to the PersonRepository. The source code of the relevant parts of the RepositoryPersonService is given in following:
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service
public class RepositoryPersonService implements PersonService {
private static final Logger LOGGER = LoggerFactory.getLogger(RepositoryPersonService.class);
protected static final int NUMBER_OF_PERSONS_PER_PAGE = 5;
@Resource
private PersonRepository personRepository;
@Transactional(readOnly = true)
@Override
public List<Person> search(String searchTerm, int pageIndex) {
LOGGER.debug("Searching persons with search term: " + searchTerm);
//Passes the specification created by PersonSpecifications class and the page specification to the repository.
Page requestedPage = personRepository.findAll(lastNameIsLike(searchTerm), constructPageSpecification(pageIndex));
return requestedPage.getContent();
}
/**
* Returns a new object which specifies the the wanted result page.
* @param pageIndex The index of the wanted result page
* @return
*/
private Pageable constructPageSpecification(int pageIndex) {
Pageable pageSpecification = new PageRequest(pageIndex, NUMBER_OF_PERSONS_PER_PAGE, sortByLastNameAsc());
return pageSpecification;
}
/**
* Returns a Sort object which sorts persons in ascending order by using the last name.
* @return
*/
private Sort sortByLastNameAsc() {
return new Sort(Sort.Direction.ASC, "lastName");
}
}
I also had to modify the unit tests of the RepositoryPersonService class. The source code of the modified unit test is given in following:
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import static junit.framework.Assert.assertEquals;
import static org.mockito.Mockito.*;
public class RepositoryPersonServiceTest {
private static final long PERSON_COUNT = 4;
private static final int PAGE_INDEX = 1;
private static final Long PERSON_ID = Long.valueOf(5);
private static final String FIRST_NAME = "Foo";
private static final String FIRST_NAME_UPDATED = "FooUpdated";
private static final String LAST_NAME = "Bar";
private static final String LAST_NAME_UPDATED = "BarUpdated";
private static final String SEARCH_TERM = "foo";
private RepositoryPersonService personService;
private PersonRepository personRepositoryMock;
@Before
public void setUp() {
personService = new RepositoryPersonService();
personRepositoryMock = mock(PersonRepository.class);
personService.setPersonRepository(personRepositoryMock);
}
@Test
public void search() {
List<Person> expected = new ArrayList<Person>();
Page expectedPage = new PageImpl(expected);
when(personRepositoryMock.findAll(any(Specification.class), any(Pageable.class))).thenReturn(expectedPage);
List<Person> actual = personService.search(SEARCH_TERM, PAGE_INDEX);
ArgumentCaptor<Pageable> pageArgument = ArgumentCaptor.forClass(Pageable.class);
verify(personRepositoryMock, times(1)).findAll(any(Specification.class), pageArgument.capture());
verifyNoMoreInteractions(personRepositoryMock);
Pageable pageSpecification = pageArgument.getValue();
assertEquals(PAGE_INDEX, pageSpecification.getPageNumber());
assertEquals(RepositoryPersonService.NUMBER_OF_PERSONS_PER_PAGE, pageSpecification.getPageSize());
assertEquals(Sort.Direction.ASC, pageSpecification.getSort().getOrderFor("lastName").getDirection());
assertEquals(expected, actual);
}
}
I have now described the parts of the source code which are using Spring Data JPA for implementing the new requirements. However, my example application has a lot of web application specific “plumbing” code in it. I recommend that you take a look of the source code because it can help you to get a better view of the big picture.
What is Next?
I have now demonstrated to you how you can paginate your query results with Spring Data JPA. If you are interested of seeing my example application in action, you can get it from Github. The next part of my Spring Data JPA tutorial will describe how you can add custom functionality to your repository.
Petri April 25, 2012 at 6:11 pm
I stumbled into this information about Spring MVC controllers and the Pageable interface:
http://static.springsource.org/spring-data/data-jpa/docs/1.0.3.RELEASE/reference/html/#web-pagination
It explains how you can automatically resolve the Pageable argument by passing specific request parameters to the request. This seems useful, if you don’t mind creating a dependency between your controllers and the Spring Data. At first I thought of updating my example application, but after giving it some thought, I decided to leave it as an exercise for the reader.
Rajesh July 16, 2012 at 8:16 am
hi petri ,
i am running you apps in my system but i am using PostgreSQL is the db but you apps is not running .
please tell what are changes i need to do
Petri July 16, 2012 at 10:11 am
Hi Rajesh,
Have you removed H2 database dependency from the pom.xml and added the PostgreSQL JDBC driver dependency to it? If you have done this and are still having problems, please let me know what the exact problem is.
Tvan August 14, 2012 at 8:54 pm
Hi Petri,
I run your example with Maven. I do not see nowhere the pagination even I created manually 22 persons. Do I understand the term “pagination” ? For me it means I can see the current page the links for next page or/and previous page. If your tutorial application is coded to see 10 persons per page, I have to see a link to go to the second page because i have 22 persons.
I do not see the configuration of number of unit per page
Thanks for your explanantion.
Tvan
Petri August 14, 2012 at 9:44 pm
Hi Tvan,
thanks for your comment. Your understanding of the term “pagination” is correct. However, I did cut some corners in the example application as I mentioned in beginning of my blog entry. The requirements of my example application are:
RepositoryPersonServiceclass (Look for a constant calledNUMBER_OF_PERSONS_PER_PAGE).Naturally this kind of limitation is out of the question in a real world application but since it is not really relevant in the context of this tutorial, I think that is acceptable.
If you want to add the number of items selection to the search result page, you have to make following changes to the example application:
pageSizevariable toSearchDTOclass.PersonServiceclass’search()method to takepageSizeas a parameter.search()method to use the parameter instead of theNUMBER_OF_ITEMS_PER_PAGEconstant.search()method of thePersonControllerclass to pass the new parameter forward to thesearch()method ofPersonService.I hope that this was helpful.
Tvan August 14, 2012 at 10:53 pm
Hi Petri,
I see it. It’s useful this tutorial on pagination.
Thank you!
Tvan
Tvan August 14, 2012 at 11:36 pm
Dear Petri,
It seems limited or against the principle of OOP if Spring-data pagination is bound only to JPA!
Is it possible to use spring-data pagination with Hibernate ?
Thanks!
Tvan
Petri August 15, 2012 at 8:21 am
Hi Tvan,
My example application uses Hibernate so the answer is yes. However, you have to use it as a JPA provider. This means that you cannot use the Hibernate query language or its criteria implementation (Unless you create a custom repository. This is a lot of hassle, which is not probably worth it). You can use Hibernate specific annotations in your entities if you are ready tie your application with Hibernate.
The idea behind this is that you can (in theory) switch the JPA provider without making any changes to your code. However, if you make a change like this, I would recommend testing your application because the different JPA providers will behave differently in certain situations.
Stephane April 24, 2013 at 11:15 am
Hello Petri,
I’m now coding a Spring Data JPA2 pet project and just found out about your book from this article, and bought it right away from the Packt website. Nice to see a finnish coder ! (I’m french but live in Tallinn). Thanks for the article !
Kind Regards,
Petri April 24, 2013 at 1:46 pm
Hi Stephane,
Thank you for your kind words. I am happy to hear that you liked this blog post.
Also, thank you for buying my book. I hope that you enjoy reading it!