How to consume a REST API using restTemplate that returns an object with Page object within it?

Question

API request and response:

Request: http://localhost:5555/api/products?page=1&size=100

Response:

{
    "reports": {
        "content": [
            {
                "productCatTx": "ERROR_product",
                "productValTx": "000",
                "productShrtDescTx": "NO_ERROR",
                "productLongDescTx": "No Error in response"
            },
            {
                "productCatTx": "ERROR_product",
                "productValTx": "010",
                "productShrtDescTx": "PRODUCT_ACCEPTED",
                "productLongDescTx": "Product Accepted"
            }
        ],
        "pageable": {
            "sort": {
                "empty": false,
                "sorted": true,
                "unsorted": false
            },
            "offset": 0,
            "pageNumber": 0,
            "pageSize": 100,
            "unpaged": false,
            "paged": true
        },
        "totalElements": 321,
        "totalPages": 4,
        "last": false,
        "size": 100,
        "number": 0,
        "sort": {
            "empty": false,
            "sorted": true,
            "unsorted": false
        },
        "numberOfElements": 100,
        "first": true,
        "empty": false
    }
}

Client REST API call from another project:

@GetMapping("/paginatedWResponseData")
    public void getProductsWResponseData() {
        RestTemplate restTemplate = new RestTemplate();
        String resourceUrl = "http://localhost:5555/api/products?page=1&size=100";

        UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromUriString(resourceUrl)
                .queryParam("page", 1)
                .queryParam("size", 100);

        ResponseEntity<ReportResponse> responseEntity = restTemplate.exchange(uriBuilder.toUriString(),
                HttpMethod.GET, null, ReportResponse.class);

        System.out.println(responseEntity);
    }

ReportResponse.java

@Data
@Builder
@FieldDefaults(level = AccessLevel.PRIVATE)
public class ReportResponse extends CustomPageImpl implements Serializable {

    Page<Product> reportData;

    @JsonCreator
    public ReportResponse(@JsonProperty("reports") Page<Product> reportData) {
        super(reportData.getContent());
        this.reportData = reportData;
    }

}

CustomPageImpl.java

public class CustomPageImpl<T> extends PageImpl<T> {

    @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
    public CustomPageImpl(@JsonProperty("content") List<T> content, @JsonProperty("number") int number,
                          @JsonProperty("size") int size, @JsonProperty("totalElements") Long totalElements,
                          @JsonProperty("pageable") JsonNode pageable, @JsonProperty("last") boolean last,
                          @JsonProperty("totalPages") int totalPages, @JsonProperty("sort") JsonNode sort,
                          @JsonProperty("numberOfElements") int numberOfElements) {
        super(content, PageRequest.of(number, 1), 10);
    }

    public CustomPageImpl(List<T> content, Pageable pageable, long total) {
        super(content, pageable, total);
    }

    public CustomPageImpl(List<T> content) {
        super(content);
    }

    public CustomPageImpl() {
        super(new ArrayList<>());
    }
}

Error:

2023-08-24T13:58:53.372-04:00 ERROR 20304 --- [nio-5656-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: org.springframework.http.converter.HttpMessageConversionException: Type definition error: [simple type, class org.springframework.data.domain.Page]] with root cause

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `org.springframework.data.domain.Page` (no Creators, like default constructor, exist): abstract types either need to be mapped to concrete types, have custom deserializer, or contain additional type information
 at [Source: (org.springframework.util.StreamUtils$NonClosingInputStream); line: 1, column: 12] (through reference chain: net.code.sample.ReportResponse["reports"])

Answer 1

The stacktrace is telling you that Jackson library can't create a org.springframework.data.domain.Page instance because it has no constructor, and it makes sense because is an interface.

I think what you actually need is adjust ReportResponse to receive a CustomPageImpl instance as argument in its constructor. Additionally you could also get rid of inheritance like this:

@Data
@Builder
@FieldDefaults(level = AccessLevel.PRIVATE)
public class ReportResponse implements Serializable {

    private final CustomPageImpl<Product> reportData;

    @JsonCreator
    public ReportResponse(@JsonProperty("reports") CustomPageImpl<Product> reportData) {
        this.reportData = reportData;
    }

    public CustomPageImpl<Product> getReportData() {
        return this.reportData;
    }
}

Answer 2

You will have to make a custom deserializer and then annotate the CustomPageImpl class to tell jackson to use the custom deserializer.

Custom Deserializer

public class CustomPageDeserializer<T> extends StdDeserializer<CustomPageImpl<T>> {

    public CustomPageDeserializer() {
        this(null);
    }

    public CustomPageDeserializer(Class<?> vc) {
        super(vc);
    }

    @Override
    public CustomPageImpl<T> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        JsonNode node = jsonParser.getCodec().readTree(jsonParser);

        List<T> content = // Extract content from the node
        int number = // Extract number from the node
        int size = // Extract size from the node
        Long totalElements = // Extract totalElements from the node
        boolean last = // Extract last from the node
        int totalPages = // Extract totalPages from the node
        int numberOfElements = // Extract numberOfElements from the node

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

        return new CustomPageImpl<>(content, pageable, totalElements);
    }
}

How to annotate

@JsonDeserialize(using = CustomPageDeserializer.class)
public class CustomPageImpl<T> extends PageImpl<T> {

Answer 3

I try this in fresh spring boot 3.1.13 project with success:

package com.example.demo;

import java.util.HashMap;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Service;

import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonUnwrapped;
import com.fasterxml.jackson.databind.ObjectMapper;

@Service
public class Autoexec implements ApplicationRunner {

    private static final String TEST_JSON = """
    {
        "reports": {
            "content": [
                {
                    "productCatTx": "ERROR_product",
                    "productValTx": "000",
                    "productShrtDescTx": "NO_ERROR",
                    "productLongDescTx": "No Error in response"
                },
                {
                    "productCatTx": "ERROR_product",
                    "productValTx": "010",
                    "productShrtDescTx": "PRODUCT_ACCEPTED",
                    "productLongDescTx": "Product Accepted"
                }
            ],
            "pageable": {
                "sort": {
                    "empty": false,
                    "sorted": true,
                    "unsorted": false
                },
                "offset": 0,
                "pageNumber": 0,
                "pageSize": 100,
                "unpaged": false,
                "paged": true
            },
            "totalElements": 321,
            "totalPages": 4,
            "last": false,
            "size": 100,
            "number": 0,
            "sort": {
                "empty": false,
                "sorted": true,
                "unsorted": false
            },
            "numberOfElements": 100,
            "first": true,
            "empty": false
        }
    }
    """;

    private final ObjectMapper objectMapper;

    @Autowired
    public Autoexec(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        final var response = objectMapper.readValue(TEST_JSON, ProductListResponse.class);
        System.err.println(response.getContent());
    }

    static class ProductListResponse extends Response<List<Product>> {
    }

    static class Product {

        public String productCatTx;
        public String productValTx;
        public String productShrtDescTx;
        public String productLongDescTx;
        
        @Override
        public String toString() {
            return "Product [productCatTx=" + productCatTx + ", productValTx=" + productValTx + ", productShrtDescTx="
                    + productShrtDescTx + ", productLongDescTx=" + productLongDescTx + "]";
        }

    }

    static class Response<T> {

        
        private Page<T> page;

        @JsonAnySetter
        public void setProperty(String name, Page<T> value) {
            page = value;
        }

        public T getContent() {
            return page == null ? null : page.content;
        }

    }

    static class Page<T> {

        public T content;

    }
}

You can add additional attributes to page class, make fields private and add getters/setters, etc.

Result:

[Product [productCatTx=ERROR_product, productValTx=000, productShrtDescTx=NO_ERROR, productLongDescTx=No Error in response], Product [productCatTx=ERROR_product, productValTx=010, productShrtDescTx=PRODUCT_ACCEPTED, productLongDescTx=Product Accepted]]