How does Spring Boot support pagination and sorting in REST APIs?

Spring Boot, particularly with Spring Data projects (like Spring Data JPA), provides robust and straightforward mechanisms to handle pagination and sorting in RESTful APIs, significantly reducing boilerplate code. It leverages the `Pageable` interface and `Page` object for this purpose.

Core Concepts: Pageable and Page

The central components for pagination and sorting in Spring Data are the Pageable interface and the Page<T> object. The Pageable interface encapsulates pagination information (page number, page size) and sorting information (sort direction, properties). The Page<T> object is returned by repository methods and contains a slice of the total data, along with metadata about the total number of elements and pages.

Enabling Pagination in REST Endpoints

To enable pagination, you can simply declare a Pageable object as a parameter in your Spring MVC controller method. Spring Boot automatically resolves the Pageable instance from request parameters (typically page, size, and sort).

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/products")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping
    public Page<Product> getAllProducts(Pageable pageable) {
        return productService.findAllProducts(pageable);
    }
}

In your service or repository layer, methods typically accept a Pageable object and return a Page<T> object. Spring Data JPA repositories automatically implement methods that accept Pageable.

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    // Spring Data JPA automatically generates implementation for this method
    Page<Product> findAll(Pageable pageable);

    Page<Product> findByCategory(String category, Pageable pageable);
}

The Page<T> object returned contains:

• getContent(): The list of actual elements for the current page.
• getNumber(): The current page number (0-indexed).
• getSize(): The requested page size.
• getTotalElements(): The total number of elements across all pages.
• getTotalPages(): The total number of available pages.
• isFirst() / isLast(): Boolean indicating if it's the first/last page.
• hasNext() / hasPrevious(): Boolean indicating if there's a next/previous page.

Enabling Sorting in REST Endpoints

Sorting is seamlessly integrated with pagination through the Pageable interface. Clients can specify sorting parameters directly in the URL. The sort parameter typically takes a property name followed by a comma and the sort direction (e.g., propertyName,asc or propertyName,desc). Multiple sort criteria can be chained.

/products?page=0&size=10&sort=name,asc
/products?page=1&size=5&sort=price,desc&sort=name,asc

Client-Side Parameters

Customizing Pagination and Sorting Behavior

Spring Boot provides the PageableHandlerMethodArgumentResolver to customize the default behavior of Pageable. You can configure default page size, max page size, and the parameter names for page and size.

import org.springframework.context.annotation.Configuration;
import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        PageableHandlerMethodArgumentResolver resolver = new PageableHandlerMethodArgumentResolver();
        resolver.setFallbackPageable(org.springframework.data.domain.PageRequest.of(0, 5)); // Default page 0, size 5
        resolver.setMaxPageSize(20); // Maximum page size allowed is 20
        // resolver.setPageParameterName("p"); // Custom page parameter name
        // resolver.setSizeParameterName("s"); // Custom size parameter name
        resolvers.add(resolver);
    }
}

Conclusion

Spring Boot, through its integration with Spring Data, offers an incredibly convenient and powerful way to add pagination and sorting capabilities to REST APIs. By simply using the Pageable interface in controller methods and repository signatures, developers can implement these features with minimal code, focusing more on business logic rather than infrastructure concerns.