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

Interface	Purpose
Pageable	Defines pagination info: page number, page size, and optional sorting. Usually instantiated using PageRequest.of().
Sort	Defines sorting logic for one or more fields, ascending or descending. Created with Sort.by().
Page<T>	Represents a page of data and includes metadata like total pages (getTotalPages()) and total elements (getTotalElements()). Executes an extra count query.
Slice<T>	Represents a slice of data without fetching total count, making it more efficient for infinite scrolling (hasNext(), hasPrevious()).

---

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.