java - pageable - Cómo consumir la respuesta de la página<Entity> usando Spring RestTemplate

resttemplate spring headers

Question

Estoy usando Spring Data (mongoDb) y tengo mi repositorio:

public interface StoriesRepository extends PagingAndSortingRepository<Story, String> {}

Entonces tengo un controlador:

@RequestMapping(method = RequestMethod.GET)
public ResponseEntity<Page<StoryResponse>> getStories(Pageable pageable) {
    Page<StoryResponse> stories = storiesRepository.findAll(pageable).map(StoryResponseMapper::toStoryResponse);
    return ResponseEntity.ok(stories);
}

Todo funciona bien, pero no puedo consumir mi punto final con el método RestTemplate getForEntity:

def entity = restTemplate.getForEntity(getLocalhost("/story"), new TypeReference<Page<StoryResponse>>(){}.class)

¿Qué clase debo proporcionar para deserializar con éxito mi página de entidades?

Answer 1

Como se mencionó en "pathfinder", puede usar el método de exchange de RestTemplate . Sin embargo, en lugar de pasar ParameterizedTypeReference<Page<StoryResponse>>() , debe pasar ParameterizedTypeReference<PagedResources<StoryResponse>>() . Cuando obtenga la respuesta, podrá recuperar el contenido: Collection<StoryResponse> .

El código debería verse así:

ResponseEntity<PagedResources<StoryResponse>> response = restTemplate.exchange(getLocalhost("/story"),
        HttpMethod.GET, null, new ParameterizedTypeReference<PagedResources<StoryResponse>>() {});
PagedResources<StoryResponse> storiesResources = response.getBody();
Collection<StoryResponse> stories = storiesResources.getContent();

Además del contenido, storiesResources contiene metadatos de página y enlaces.

Una explicación más paso a paso está disponible aquí: https://stackoverflow.com/a/46847429/8805916

Answer 2

Probablemente pueda usar el método de intercambio de descanso y obtener el cuerpo de él.

Verifique la siguiente respuesta https://.com/a/31947188/3800576 . Esto podría ayudarte

Answer 3

Puedes intentar agregar la anotación @ResponseBody:

@RequestMapping(method = RequestMethod.GET)
@ResponseBody
public ResponseEntity<Page<StoryResponse>> getStories(@RequestBody Pageable pageable) {
    Page<StoryResponse> stories = storiesRepository.findAll(pageable).map(StoryResponseMapper::toStoryResponse);
    return ResponseEntity.ok(stories);
}

Answer 4

Sé que este hilo es un poco viejo, pero espero que alguien se beneficie de esto.

La respuesta de @Ali Dehghani es buena, excepto que reimplementa lo que ya ha hecho PageImpl<T> . Consideré esto como algo innecesario. Encontré una mejor solución al crear una clase que extiende PageImpl<T> y especifica un constructor @JsonCreator :

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.company.model.HelperModel;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;

import java.util.List;

public class HelperPage extends PageImpl<HelperModel> {

    @JsonCreator
    // Note: I don''t need a sort, so I''m not including one here.
    // It shouldn''t be too hard to add it in tho.
    public HelperPage(@JsonProperty("content") List<HelperModel> content,
                      @JsonProperty("number") int number,
                      @JsonProperty("size") int size,
                      @JsonProperty("totalElements") Long totalElements) {
        super(content, new PageRequest(number, size), totalElements);
    }
}

Entonces:

HelperPage page = restTemplate.getForObject(url, HelperPage.class);

Esto es lo mismo que crear una CustomPageImpl<T> pero nos permite aprovechar todo el código que ya está en PageImpl<T> .

Answer 5

Si observa este hilo y prueba esta respuesta https://.com/a/44895867/8268335

Usted encontrará el segundo problema:

Can not construct instance of org.springframework.data.domain.Pageable

Entonces encuentro la solución perfecta desde aquí: https://.com/a/42002709/8268335

Creo la clase RestPageImpl de la respuesta anterior y el problema resuelto.

Answer 6

Solo puedo hacer que funcione degradando la biblioteca Spring a 1. * y no utilizando 2. * Tuve que crear mi propio código para la página que no se extiende a PageImpl

Answer 7

new TypeReference<Page<StoryResponse>>() {}

El problema con esta afirmación es que Jackson no puede crear una instancia de un tipo abstracto. Debe darle a Jackson la información sobre cómo crear una instancia de Page con un tipo concreto. Pero su tipo concreto, PageImpl , no tiene un constructor predeterminado ni ningún @JsonCreator s, por lo que tampoco puede usar el siguiente código:

new TypeReference<PageImpl<StoryResponse>>() {}

Como no puede agregar la información requerida a la clase de Page , es mejor crear una implementación personalizada para la interfaz de Page que tenga un constructor predeterminado sin argumentos, como en esta answer . Luego use esa implementación personalizada en la referencia de tipo, como la siguiente

new TypeReference<CustomPageImpl<StoryResponse>>() {}

Aquí están la implementación personalizada, copiada de la pregunta vinculada:

public class CustomPageImpl<T> extends PageImpl<T> {
    private static final long serialVersionUID = 1L;
    private int number;
    private int size;
    private int totalPages;
    private int numberOfElements;
    private long totalElements;
    private boolean previousPage;
    private boolean firstPage;
    private boolean nextPage;
    private boolean lastPage;
    private List<T> content;
    private Sort sort;

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

    @Override
    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    @Override
    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public int getTotalPages() {
        return totalPages;
    }

    public void setTotalPages(int totalPages) {
        this.totalPages = totalPages;
    }

    @Override
    public int getNumberOfElements() {
        return numberOfElements;
    }

    public void setNumberOfElements(int numberOfElements) {
        this.numberOfElements = numberOfElements;
    }

    @Override
    public long getTotalElements() {
        return totalElements;
    }

    public void setTotalElements(long totalElements) {
        this.totalElements = totalElements;
    }

    public boolean isPreviousPage() {
        return previousPage;
    }

    public void setPreviousPage(boolean previousPage) {
        this.previousPage = previousPage;
    }

    public boolean isFirstPage() {
        return firstPage;
    }

    public void setFirstPage(boolean firstPage) {
        this.firstPage = firstPage;
    }

    public boolean isNextPage() {
        return nextPage;
    }

    public void setNextPage(boolean nextPage) {
        this.nextPage = nextPage;
    }

    public boolean isLastPage() {
        return lastPage;
    }

    public void setLastPage(boolean lastPage) {
        this.lastPage = lastPage;
    }

    @Override
    public List<T> getContent() {
        return content;
    }

    public void setContent(List<T> content) {
        this.content = content;
    }

    @Override
    public Sort getSort() {
        return sort;
    }

    public void setSort(Sort sort) {
        this.sort = sort;
    }

    public Page<T> pageImpl() {
        return new PageImpl<>(getContent(), new PageRequest(getNumber(),
                getSize(), getSort()), getTotalElements());
    }
}