Pagination & Sorting

When working with large datasets, fetching all records at once is inefficient and can slow down your application.

Spring Data JPA provides built-in support for pagination and sorting, allowing you to fetch data in pages and in a specific order.

What is Pagination?

Pagination allows you to retrieve data page by page instead of fetching the entire table.

Key Classes

• Pageable → Defines page number, page size, and optional sorting
• Page<T> → Contains the results, total pages, total elements, and current page info

Repository Method Example

• This heading indicates a sample method in the repository to show how pagination is implemented.
• It introduces how to define methods that accept a Pageable parameter and return a Page<T> object.

Page<User>findByStatus(String status, Pageable pageable);

Usage Example

• Shows how to actually call the repository method in your service or controller.
• Demonstrates creating a Pageable object, executing the query, and retrieving data and metadata.

Pageablepageable= PageRequest.of(0,10);// Page 0, 10 records per page
Page<User> usersPage = userRepository.findByStatus("ACTIVE", pageable);

System.out.println("Total pages: " + usersPage.getTotalPages());
System.out.println("Total users: " + usersPage.getTotalElements());

List<User> users = usersPage.getContent();// Users in the current page

Key Points

• Pages are zero-indexed (first page = 0)
• Page contains metadata useful for UI pagination
• Works with derived queries and @Query methods

What is Sorting?

Sorting allows you to retrieve data in a specific order by one or more fields.

Repository Method Example

• This heading shows how to define repository methods that support sorting.
• Indicates that you can pass a Sort object as a parameter to dynamically order the query results.

List<User>findAll(Sort sort);
List<User>findByRole(String role, Sort sort);

Usage Example – Single Field

• Demonstrates how to use a repository method to sort results by a single field.
• Highlights that you can specify the sort direction (ascending or descending) for one property.

List<User> users = userRepository.findAll(Sort.by(Sort.Direction.ASC,"name"));

Usage Example – Multiple Fields

• Demonstrates how to sort query results by multiple fields at once.
• Useful when you want a primary and secondary sorting order (e.g., first by status ascending, then by created date descending).

List<User> users = userRepository.findAll(
    Sort.by(Sort.Order.asc("status"), Sort.Order.desc("createdDate"))
);

Key Interfaces

Implementing Pagination

• Indicates the section teaches how to fetch data page by page instead of loading the full dataset.
• Improves performance when working with large tables.

Step 1: Repository Interface

• Defines the repository interface for the Book entity.
• Extending JpaRepository automatically provides CRUD operations plus pagination and sorting capabilities.
• No need for custom methods for basic paging or sorting.

publicinterfaceBookRepositoryextendsJpaRepository<Book, Long> {
}

Step 2: Create Pageable Object

• Describes how to define the pagination and sorting parameters in your code.
• PageRequest.of(page, size) specifies which page to fetch and how many records per page.
• Adding a Sort object lets you combine pagination and sorting in one request.

// Pagination only: page 0, 10 records per page
Pageablepageable= PageRequest.of(0,10);

// Pagination with sorting: page 0, 10 records, sorted by title ascending
PageablepageableSorted= PageRequest.of(0,10, Sort.by("title").ascending());

Step 3: Use in Service Layer

• Explains how to actually use the repository and pageable object to fetch a page of data in your service class.
• The Page<T> object returned contains both the list of records (content) and metadata like total pages, total elements, and current page info.
• Pages are zero-indexed, meaning the first page is 0.

@Autowired
private BookRepository bookRepository;

publicvoidgetPaginatedBooks(int page,int size) {
Pageablepageable= PageRequest.of(page, size);
    Page<Book> bookPage = bookRepository.findAll(pageable);

    List<Book> books = bookPage.getContent();
inttotalPages= bookPage.getTotalPages();
longtotalElements= bookPage.getTotalElements();

    System.out.println("Total Pages: " + totalPages);
    System.out.println("Total Elements: " + totalElements);
    books.forEach(System.out::println);
}

Implementing Sorting

• This heading indicates the section explains how to order query results instead of just fetching them.
• Sorting allows you to retrieve data in a specific order (ascending/descending) based on one or more fields.

Step 1: Sort by Single Field

• Describes sorting results using just one field.
• You can specify ascending or descending order using the Sort.by() method.

List<Book> books = bookRepository.findAll(Sort.by("title").ascending());

Step 2: Sort by Multiple Fields

• Explains sorting results by more than one field.
• The .and() method allows you to combine multiple sort criteria, applied in sequence.
• Example: first sorts by author ascending, then by title descending for records with the same author.

List<Book> books = bookRepository.findAll(
    Sort.by("author").ascending()
        .and(Sort.by("title").descending())
);

Combining Pagination and Sorting

You can combine pagination and sorting using Pageable:

Pageablepageable= PageRequest.of(0,10, Sort.by("title").ascending());
Page<Book> bookPage = bookRepository.findAll(pageable);

List<Book> books = bookPage.getContent();

Here,

• PageRequest.of(0, 10, Sort.by("title").ascending()) → Fetch first page, 10 records per page, sorted by title ascending.
• bookRepository.findAll(pageable) → Returns a Page with the records and metadata.
• bookPage.getContent() → Gets the list of books from the current page.

Using Pageable in REST Controllers

Spring Data REST makes it easy to implement pagination and sorting in REST APIs by automatically mapping request parameters to a Pageable object.

Request Example

GET /books?page=0&size=5&sort=title,asc

• page=0 → fetch the first page (zero-indexed).
• size=5 → 5 records per page.
• sort=title,asc → sort results by title in ascending order.

Example with Named Query

• Supports dynamic pagination and sorting through URL parameters.
• Works seamlessly with derived queries or custom named queries.

@RestResource(path = "titleStartsWith", rel = "titleStartsWith")
public Page<Book>findByTitleStartsWith(@Param("title") String title, Pageable pageable);

Benefits

• Reduces memory usage by fetching only required records
• Improves performance on large datasets
• Supports dynamic queries with sorting and pagination
• Integrates seamlessly with Spring Data repositories and REST APIs
• Enables UI features like page sliders and infinite scrolling

Conclusion

Spring Data JPA’s Pageable and Sort interfaces make it easy to implement efficient, scalable, and user-friendly applications. They allow you to fetch data in pages, sort by multiple fields, and expose paginated data via REST APIs with minimal boilerplate code.