JHipster Repository ↔ Spring Data JPA Pageable: How to enforce a global max page size?

Answer the question first

The simplest, most reliable way to limit the page size in a JHipster application is to set the Spring Boot property spring.data.web.pageable.max-page-size (and optionally default-page-size) in application.yml or application.properties. Spring’s PageableHandlerMethodArgumentResolver reads this property before the controller is invoked, so the Pageable object that reaches the repository and PaginationUtil already contains the capped size. The pagination metadata (total count, link headers) remains correct because it is computed from that same Pageable instance.

Why this is the recommended approach

• It is a framework‑level configuration, so it applies automatically to every pageable controller without code duplication.
• It keeps JHipster’s one‑indexed page handling intact; the resolver still interprets page=0 as the first page.
• There is no need for custom Pageable implementations, request filters, or global exception handlers that would have to replicate the same logic and could mis‑align the link headers.
• The property is supported in Spring Boot 2.6+ and Spring Data JPA 2.6+, which are the versions typically used by recent JHipster releases.

Steps for a typical JHipster project

1. Open src/main/resources/application.yml (or application.properties). Add or update the following lines:

   spring:
     data:
       web:
         pageable:
           max-page-size: 100  # maximum rows a client can request
           default-page-size: 20  # optional default
   

2. Ensure that the project does not declare a custom PageableHandlerMethodArgumentResolver bean. If such a bean exists, remove or adjust it so that the resolver’s setMaxPageSize method uses the same value.
3. Rebuild and restart the application.
4. Verify the cap: send a request such as /api/users?page=0&size=1000 and confirm the response body contains only 100 records and that the Link header reflects size=100.

Handling older Spring Boot / Spring Data versions

If your project uses Spring Boot 2.4 or earlier, the max-page-size property is not exposed. In that case you can create a small configuration class to supply a customized resolver:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.web.PageableHandlerMethodArgumentResolver;

@Configuration
public class PageableConfig {
    @Bean
    public PageableHandlerMethodArgumentResolver pageableResolver() {
        PageableHandlerMethodArgumentResolver resolver = new PageableHandlerMethodArgumentResolver();
        resolver.setMaxPageSize(100);   // your desired cap
        resolver.setOneIndexedParameters(true); // keep JHipster’s 0‑based page handling
        return resolver;
    }
}

After adding this bean, the resolver will enforce the cap before any controller method is invoked, and the rest of the stack behaves as if the property had been set.

Things to double‑check

• Confirm the Spring Boot and Spring Data JPA versions in pom.xml (or build.gradle). The property is available from Spring Boot 2.6+; earlier versions require the custom bean.
• Ensure that no other configuration (e.g., a custom PageableHandlerMethodArgumentResolver bean or a filter that rewrites query parameters) overrides the default resolver.
• Test that the X‑Total‑Count and Link headers still match the capped page size by inspecting a response to a large‑size request.

Missing diagnostic detail

Could you confirm which Spring Boot and Spring Data JPA versions your JHipster project is using? That will tell us whether the spring.data.web.pageable.max-page-size property is available out of the box or if a custom resolver bean is required.