Spring Data JPA教程, 第七部分: Pagination（未翻译）

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 theJpaSpecificationExecutor<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 thegetContent() 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 ispageIndex and it specifies the index of the wanted page. The declaration of the new search()methods is given in following:

public interface PersonService {

/**
* 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, theRepositoryPersonService 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 org.springframework.data.jpa.domain.Specification;

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 thePersonRepository. I created a private method called constructPageSpecification() to theRepositoryPersonService. 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.Logger;
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.Before;
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 codebecause 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.