Pagination

Pagination means: Don't retrieve thousands or millions of records at once. Retrieve a limited subset.

Suppose your database has 100,000 employees. Instead of selecting all 100,000 rows into memory (which would crash your application), we want to fetch them in manageable chunks:

Page 0 → 20 records
Page 1 → 20 records
Page 2 → 20 records

In Spring Data JPA, this is incredibly easy. You just update your repository method to accept a Pageable object and return a Page:

Page<Employee> findAll(Pageable pageable);

When calling the method, you pass a PageRequest:

PageRequest.of(0, 20);

This means: Give me page index 0 (the first page), with a size of 20 records per page.

32. Sorting + Pagination

It is very rare that you want to paginate unsorted data. A very common real-world pattern is to combine sorting and pagination together.

Here is an example in Spring Data:

PageRequest.of(
    0,
    20,
    Sort.by("salary").descending()
);

Conceptually, this breaks down to:

• Page: 0 (First page)
• Size: 20 records
• Sort: By salary in DESC order (highest paid first)

Why Database-Level Pagination is Critical

Database-level pagination is important because you DO NOT want this to happen:

Database
   ↓
(Returns 100,000 rows)
   ↓
Java Memory
   ↓
(Java discards 99,980 rows to take the first 20)

Instead, the database itself should perform the limiting and pagination. When you use Spring Data's Pageable, Hibernate translates this into highly efficient SQL constraints:

Database
   ↓
ORDER BY (Sorts data)
   ↓
LIMIT / OFFSET (Limits to 20 rows natively in the DB)
   ↓
(Returns exactly 20 rows)
   ↓
Java Application

Interactive Demo: Pagination and Sorting UI

To truly understand why we paginate, play with the interactive table below. It simulates a dataset of 50 records. Use the pagination controls at the bottom to jump between pages, and click the column headers to sort the data. Notice how the page size limits exactly how many DOM elements are rendered at once!