Pagination and Sorting in Spring Boot

-

Introduction :

When working with large amounts of data, fetching all records at once can impact application performance and increase response time.

To solve this problem, Spring Boot provides Pagination and Sorting features through Spring Data JPA.

Pagination allows us to fetch data in smaller chunks (pages), while Sorting helps organize data in ascending or descending order.

In this tutorial, we will learn:

✅ Pagination using Pageable

✅ PageRequest

✅ Sorting using Sort

✅ REST API examples

Why Do We Need Pagination?

Imagine an Employee table containing 10,000 records.

If an API fetches all records at once:

employeeRepository.findAll();

it can:

  • Increase response time

  • Consume more memory

  • Impact application performance

Instead, we can fetch records page by page.

Example:

Page 1 → Records 1-10

Page 2 → Records 11-20

Page 3 → Records 21-30

This approach is more efficient and scalable.

Employee Repository :

Spring Data JPA already provides pagination support through JpaRepository.

@Repository
public interface EmployeeRepository
        extends JpaRepository<Employee, Long> {

}

No additional code is required.

Service Layer :

Create a method to fetch paginated employee data.

public Page<Employee> getEmployees(int page, int size) {

    Pageable pageable = PageRequest.of(page, size);

    return employeeRepository.findAll(pageable);

}

Explanation

page → Current page number

size → Number of records per page

Pageable → Pagination information

PageRequest → Creates Pageable object

Controller Layer :

Create API for pagination.

@GetMapping("/pagination")
public Page<Employee> getEmployees(
        @RequestParam int page,
        @RequestParam int size) {

    return employeeService.getEmployees(page, size);

}

Test API :

Request:

GET /employees/pagination?page=0&size=5

Response:

{
  "content": [
    {
      "id": 1,
      "name": "Sulochana",
      "email": "sulochana@gmail.com"
    }
  ],
  "totalElements": 50,
  "totalPages": 10,
  "size": 5,
  "number": 0
}

Spring Boot automatically returns pagination details.

Sorting Data :

Sorting helps display records in a specific order.

Examples:

  • Name A to Z

  • Name Z to A

  • Latest Records First

Service Layer for Sorting :

public List<Employee> getEmployeesSortedByName() {

    return employeeRepository.findAll(
            Sort.by("name"));

}

Ascending order is the default behavior.

Descending Order :

public List<Employee> getEmployeesSortedByNameDesc() {

    return employeeRepository.findAll(
            Sort.by("name").descending());

}

Controller API :

@GetMapping("/sort")
public List<Employee> getEmployeesSorted() {

    return employeeService.getEmployeesSortedByName();

}

Request:

GET /employees/sort

Pagination with Sorting :

Spring Boot allows combining pagination and sorting.

public Page<Employee> getEmployeesWithPaginationAndSorting(
        int page,
        int size) {

    Pageable pageable = PageRequest.of(
            page,
            size,
            Sort.by("name").ascending());

    return employeeRepository.findAll(pageable);

}

Controller API :

@GetMapping("/pagination-sort")
public Page<Employee> getEmployeesPaginationAndSorting(
        @RequestParam int page,
        @RequestParam int size) {

    return employeeService
            .getEmployeesWithPaginationAndSorting(
                    page,
                    size);

}

Request:

GET /employees/pagination-sort?page=0&size=5

This API returns paginated and sorted employee records.

Benefits of Pagination and Sorting :

  • Improved performance

  • Faster response times

  • Better user experience

  • Reduced memory consumption

  • Easy navigation through large datasets

Conclusion :

In this tutorial, we learned how to implement Pagination and Sorting in Spring Boot using Spring Data JPA.

We covered:

✅ Pageable

✅ PageRequest

✅ Sort

✅ Pagination API

✅ Sorting API

✅ Pagination with Sorting

These features are widely used in real-world applications to efficiently manage and display large amounts of data.

In the next tutorial, we will learn how to implement Validation in Spring Boot using @Valid and Bean Validation.

Comments

Post a Comment

Popular posts from this blog

React Basics – How to Create Component

-
  Introduction (Story) : When I started learning React, I was confused about how components actually work. I saw many examples, but things became clear only when I created my own first component. In this blog, I will explain how to create a simple React component step by step in an easy way. What is a Component in React? A component is a reusable piece of UI in React. It helps in breaking the application into smaller, manageable parts. Tools Required : Node.js React (Create React App / Vite) VS Code  Step 1: Create React App : Run the following command: Where you want create the react project, then we have to create new folder and there you can open the cmd and run below command npx create-react-app my-app Navigate to project folder: cd my-app npm start Step 2: Create Your First Component Create a file named Hello.js import React from 'react' ; function Hello () { return <h1> Hello, Welcome to React! </h1> ; } export default Hello ; Step 3: ...
Read more

How to Build REST API using Spring Boot (Step-by-Step Guide)

-
Introduction  (Story + Experience)  : When I started learning Spring Boot, I found REST APIs a bit confusing. I watched multiple tutorials, but I didn’t fully understand how backend systems actually work. Things became clear when I tried building a simple REST API on my own. In this blog, I will share the same step-by-step process that helped me understand REST APIs in a practical way. What is REST API? A REST API allows communication between frontend and backend systems using HTTP methods like GET, POST, PUT, and DELETE. In real-world applications, REST APIs are used to send and receive data between client and server. Tools Required  : - Java - Spring Boot - IntelliJ / VS Code - Postman Step 1: Create Spring Boot Project  : Go to Spring Initializr and create a project with the following dependencies: - Spring Web - Spring Data JPA - PostgreSQL Driver Step 2: Create Controller  : @RestController @RequestMapping("/api") public class HelloController {   ...
Read more

Spring Boot @RequestParam Annotation Explained with Real-Time Examples

-
Image
 Introduction : As a Java Full Stack Developer, I have worked on several Spring Boot applications where APIs needed to receive data from users. One annotation that I frequently used in REST APIs is @RequestParam . In many real-world applications, users need to search, filter, sort, or paginate data. For example, an employee management system may allow users to search employees by department, status, or employee ID. In such cases, @RequestParam provides a simple and efficient way to pass data from the client to the server through URL query parameters. When I started learning Spring Boot, I often got confused between @RequestParam , @PathVariable , and @RequestBody . However, after working on multiple projects, I understood the purpose of each annotation and when to use them effectively. In this article, I will explain the @RequestParam annotation with practical examples, project use cases, common mistakes, best practices, and interview questions. What is @RequestParam? The @Reques...
Read more