Set default page size for JPA Pageable Object

Question

I have a PagingandSorting Repository which has a method that accecpts a pageable object. I also have a controller that accepts a pageable object through the URL.

My use case is that, if a user specifies a page size parameter in the URL i must take that value for the pageable object. If he does not mention take a default value of 50.

But the pageable object defaults to 20 right now.

Any Suggestions would help

Answer 1

If you are talking about a Spring Data PagingAndSortingRepository you can set the default page size by using the @PageableDefault on a Controller method as follows:

public String listClients(@ModelAttribute FilterForm form, Model model, WebRequest request, @PageableDefault(sort = { "surname",
            "forename", "address.town" }, value = 50) Pageable pageable) {

    }

Or you can configure a global default using the following in your Spring config as shown below in both XML and Java config.

Note that newer versions of Spring Data use zero based page indexing while older versions used 1 for the first page. If your UI paging library expects 1 as first page then you can set the oneIndexedParameters property to true:

• public void setOneIndexedParameters(boolean oneIndexedParameters)

Configures whether to expose and assume 1-based page number indexes in the request parameters. Defaults to false, meaning a page number of 0 in the request equals the first page. If this is set to true, a page number of 1 in the request will be considered the first page.

Parameters: oneIndexedParameters - the oneIndexedParameters to set

• public void setFallbackPageable(Pageable fallbackPageable)

Configures the Pageable to be used as fallback in case no PageableDefault or PageableDefaults (the latter only supported in legacy mode) can be found at the method parameter to be resolved. If you set this to null, be aware that you controller methods will get null handed into them in case no Pageable data can be found in the request. Note, that doing so will require you supply bot the page and the size parameter with the requests as there will be no default for any of the parameters available.

Parameters: fallbackPageable - the Pageable to be used as general fallback.

In XML this looks like the following then:

<mvc:annotation-driven>
    <mvc:argument-resolvers>
        <bean class="org.springframework.data.web.PageableHandlerMethodArgumentResolver">
            <property name="oneIndexedParameters" value="true"/>
            <property name="fallbackPageable">
                <bean class="org.springframework.data.domain.PageRequest">
                    <constructor-arg name="page" value="1" />
                    <constructor-arg name="size" value="10" />
                </bean>
            </property>
        </bean>
    </mvc:argument-resolvers>
</mvc:annotation-driven>

In Java Config this looks like the below:

@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {


    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        PageableHandlerMethodArgumentResolver resolver = new PageableHandlerMethodArgumentResolver();
        resolver.setOneIndexedParameters(true);
        resolver.setFallbackPageable(new PageRequest(1, 20));
        argumentResolvers.add(resolver);
        super.addArgumentResolvers(argumentResolvers);
    }
}

Answer 2

For Spring Boot 2.X you have set of parameters:

# DATA WEB (SpringDataWebProperties)
spring.data.web.pageable.default-page-size=20         # Default page size.
spring.data.web.pageable.max-page-size=2000           # Maximum page size to be accepted.
spring.data.web.pageable.one-indexed-parameters=false # Whether to expose and assume 1-based page number indexes.
spring.data.web.pageable.page-parameter=page          # Page index parameter name.
spring.data.web.pageable.prefix=                      # General prefix to be prepended to the page number and page size parameters.
spring.data.web.pageable.qualifier-delimiter=_        # Delimiter to be used between the qualifier and the actual page number and size properties.
spring.data.web.pageable.size-parameter=size          # Page size parameter name.
spring.data.web.sort.sort-parameter=sort              # Sort parameter name.

Answer 3

You can set below in application.yml

spring.data.rest.default-page-size: 50

Answer 4

You can use this Annotation before your Pageable param:

@PageableDefault(size = 40)

// so your parameter should be like this:
@PageableDefault(size = 40) Pageable pageable

** Update: You can store 40 in application.yml file and use it in the whole project.

in application.yml :

pageSize: 40

then:

// so your parameter should be like this:
@PageableDefault(size = ${pageSize}) Pageable pageable

Answer 5

And, for completeness, here is an example for a Spring Boot configuration. In the @Configuration class that extends WebMvcConfigurerAdapter, set the default page size to 50 items like this:

@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
    PageableHandlerMethodArgumentResolver resolver = new PageableHandlerMethodArgumentResolver();
    resolver.setFallbackPageable(new PageRequest(0, 50));
    argumentResolvers.add(resolver);
    super.addArgumentResolvers(argumentResolvers);
}

Answer 6

This still isn't well documented but for anyone else finding this article, the RepositoryRestConfigurerAdapter has all the spring data rest config there.

@Configuration
public static class RestConfig extends RepositoryRestConfigurerAdapter {

    @Override
    public void configureRepositoryRestConfiguration(RepositoryRestConfiguration config) {
            config.setDefaultPageSize(50);
    }

}

Answer 7

In Spring Boot 2.1.6.RELEASE, you can use below:

@Configuration
public class WebConfig implements WebMvcConfigurer{

    @Value("${paging.default.pageSize}")
    private int size;

    @Value("${paging.default.page}")
    private int page;


    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        PageableHandlerMethodArgumentResolver resolver = new PageableHandlerMethodArgumentResolver();
        resolver.setFallbackPageable(PageRequest.of(page, size));
        resolvers.add(resolver);
        WebMvcConfigurer.super.addArgumentResolvers(resolvers);
    }
}

Answer 8

If there is someone who is trying to use @PageableDefault with spring.data.web.pageable.default-page-size and don't know why the default page size you set ins't working

public @interface PageableDefault {

    /**
     * The default-size the injected {@link org.springframework.data.domain.Pageable} should get if no corresponding
     * parameter defined in request (default is 10).
     */
    int size() default 10;

}

As you can see the above code if you use @PageableDefault the default page size is set to 10 no matter what you set spring.data.web.pageable.default-page-size: 99

So if you want to provide default sort condition in a simple way with page size , you can use something like this

@PageableDefault(size = 99, sort = {"createdAt"}, direction = sort.Direction.DESC) Pageable pageable

Answer 9

Provided answers are very good and should help in most cases. However, I use slightly different approach, which allows me to use different default page size per model and can be configurable with Spring or system properties.

Please note that this approach has one fundamental limitation, namely, it does not accept any size coming with a request; it uses sorting information though. So if you need ability to change number of returned items per page via request parameters, this solution is not for you.

First of all, I created a utility class (or just a method in a controller) which creates a new Pageable instance base on a request Pageable and configured page size

public static Pageable updatePageable(final Pageable source, final int size)
{
    return new PageRequest(source.getPageNumber(), size, source.getSort());
}

In a controller I add a variable which holds my default page size (in this case default value is 20 if configuration is not provided):

@Value("${myapplication.model.items-per-page:20}")
private int itemsPerPage;

And then I override (i.e. create a new Pageable instance) default page size in request handling method:

@RequestMapping(method = RequestMethod.GET)
public Page<Model> websites(final Pageable pageable)
{
    return repository.findAll(updatePageable(pageable, itemsPerPage));
}

I use different default page size variables for different models / controllers which then can be configured even from system properties.

Answer 10

To check and validate if pageable param is not present in the request (e.g. http://ipServer:8080/getfiltered/ without "page" param). I dont need use the default-page-size , just need to set pageable to unpaged. This work for me (use size param instead default to check):

public ResponseEntity<List<Object>> getAllFiltered(@RequestParam(required = false) Integer size, Pageable pageable) {
        log.debug("REST request to get all obj filtered");

        if (pageable == null || size == null) {
            pageable = Pageable.unpaged();
        }

        return = service.findAllFiltered(pageable);
}