What is Pagination in Spring Data JPA?

Pagination in Spring Data JPA is a technique used to retrieve data in smaller chunks or pages instead of loading all records at once.

In simple words:

“Pagination divides large amounts of data into smaller manageable pages.”

Why Pagination is Needed

Modern applications often contain:

Thousands of users
Millions of transactions
Large product catalogs
Huge interview question datasets

Loading all records at once can:

Reduce performance
Increase memory usage
Slow down APIs
Create poor user experience

Pagination solves these problems efficiently.

Real-Time Example

Suppose:

Your website contains 100,000 interview questions

Without pagination:

All questions load together
Application becomes very slow

With pagination:

Only 10 or 20 records load per page

How Pagination Works

Example:

Page Number	Records
Page 1	1 - 10
Page 2	11 - 20
Page 3	21 - 30

Main Components of Pagination

Spring Data JPA provides:

Pageable
Page
Slice

What is Pageable?

Pageable is an interface used to define pagination information.

It contains:

Page number
Page size
Sorting information

Pageable Example

Pageable pageable =
        PageRequest.of(0, 10);

Here:

0 → First page
10 → Records per page

What is Page?

Page represents paginated result data.

It contains:

Actual records
Total pages
Total records
Current page

Page Example

Page<Student> students =
        studentRepository.findAll(pageable);

Repository Pagination Example

public interface StudentRepository
        extends JpaRepository<Student, Long> {

}

Service Layer Example

public Page<Student> getStudents(
        int page,
        int size
) {

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

    return studentRepository.findAll(pageable);
}

Controller Example

@GetMapping("/students")
public Page<Student> getStudents(

        @RequestParam int page,

        @RequestParam int size
) {

    return studentService.getStudents(
            page,
            size
    );
}

API Request Example


GET /students?page=0&size=10

Generated SQL Query

SELECT *
FROM students
LIMIT 10 OFFSET 0

Second Page Example


GET /students?page=1&size=10

Generated SQL

SELECT *
FROM students
LIMIT 10 OFFSET 10

Pagination Response Example

{
  "content": [
    {
      "id": 1,
      "name": "Naresh"
    }
  ],

  "totalPages": 50,

  "totalElements": 500,

  "size": 10,

  "number": 0
}

Sorting with Pagination

Pagination can be combined with sorting.

Sorting Example

Pageable pageable =
        PageRequest.of(
                0,
                10,
                Sort.by("name").ascending()
        );

Descending Sort Example

Sort.by("id").descending()

Pagination with Custom Query

@Query("""
SELECT s
FROM Student s
WHERE s.name LIKE %:keyword%
""")
Page<Student> searchStudents(
        String keyword,
        Pageable pageable
);

Pagination with Native Query

@Query(
    value = """
        SELECT *
        FROM students
    """,
    nativeQuery = true
)
Page<Student> getStudents(
        Pageable pageable
);

What is Slice?

Slice is similar to Page, but it does not calculate total pages.

Why Slice is Faster

Slice avoids:

Total count query

making it more efficient for large datasets.

Slice Example

Slice<Student> students =
        studentRepository.findByName(
                "Naresh",
                pageable
        );

Difference Between Page and Slice

Feature	Page	Slice
Total Count Query	Yes	No
Total Pages Available	Yes	No
Performance	Slightly slower	Faster

Advantages of Pagination

Improves performance
Reduces memory usage
Faster API response
Better user experience
Efficient database querying

Disadvantages of Improper Pagination

Large offsets may reduce performance
Complex sorting queries
Count queries may become expensive

Real-Time Example in E-Commerce Application

E-commerce applications may contain:

Millions of products

Pagination helps:

Load products page by page
Improve website speed
Reduce server load

Real-Time Example in Interview Portal

Interview websites like:

Java interview questions
Spring Boot tutorials
Microservices questions

require pagination for:

SEO-friendly navigation
Fast content loading
Improved mobile experience

Best Practices for Pagination

Keep page size reasonable
Use sorting with pagination
Avoid extremely large offsets
Use indexes properly
Use Slice for large datasets

Common Interview Questions on Pagination