web-dev-qa-db-fra.com

Comment utiliser la réponse de la page <Entity> à l'aide de Spring RestTemplate

J'utilise des données de printemps (mongoDb) et j'ai mon référentiel:

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

Ensuite, j'ai un contrôleur:

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

Tout fonctionne bien, mais je ne peux pas utiliser mon ordinateur d'extrémité à l'aide de la méthode RestTemplate getForEntity:

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

Quelle classe dois-je fournir pour désérialiser avec succès ma page d'entités?

javaspringrestspring-dataspring-data-rest
23
bgalek
new TypeReference<Page<StoryResponse>>() {}

Le problème avec cette déclaration est que Jackson ne peut pas instancier un type abstrait. Vous devriez indiquer à Jackson comment instancier Page avec un type concret. Mais son type concret, PageImpl, n'a pas de constructeur par défaut ni aucun @JsonCreators, vous pouvez donc not utiliser le code suivant:

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

Étant donné que vous ne pouvez pas ajouter les informations requises à la classe Page, il est préférable de créer une implémentation personnalisée pour l'interface Page qui possède un constructeur sans argument par défaut, comme dans ce answer . Ensuite, utilisez cette implémentation personnalisée dans la référence de type, comme suit:

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

Voici l'implémentation personnalisée, copiée à partir d'une question liée:

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());
    }
}
29
Ali Dehghani

Je sais que ce fil est un peu vieux, mais j'espère que quelqu'un en tirera profit.

La réponse de @ALi Dehghani est bonne, sauf qu'elle ré-implémente ce que PageImpl<T> a déjà fait. Je considérais cela comme plutôt inutile. J'ai trouvé une meilleure solution en créant une classe qui étend PageImpl<T> et spécifie un constructeur @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);
    }
}

Ensuite:

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

Cela revient à créer une classe CustomPageImpl<T> mais nous permet de tirer parti de tout le code déjà présent dans PageImpl<T>.

15
jtcotton63

Comme "pathfinder" l'a mentionné, vous pouvez utiliser la méthode exchange de RestTemplate. Cependant, au lieu de passer ParameterizedTypeReference<Page<StoryResponse>>(), vous devriez passer ParameterizedTypeReference<PagedResources<StoryResponse>>(). Lorsque vous obtenez la réponse, vous pouvez récupérer le contenu - Collection<StoryResponse>.

Le code devrait ressembler à ceci:

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();

Mis à part le contenu, storiesResources contient aussi les métadonnées de page et les liens.

Une explication plus détaillée est disponible ici: https://stackoverflow.com/a/46847429/8805916

6
Vladimir Mitev

Si vous regardez ce fil et essayez cette réponse https://stackoverflow.com/a/44895867/8268335

Vous rencontrerez le 2ème problème:

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

Ensuite, je trouve la solution idéale à partir d’ici: https://stackoverflow.com/a/42002709/8268335

Je crée la classe RestPageImpl à partir de la réponse ci-dessus et du problème résolu.

0
Terrence Wei

Je ne peux que faire en sorte que cela fonctionne en rétrogradant la bibliothèque Spring vers 1. * sans utiliser 2. * Je devais créer mon propre code pour la page qui ne s'étend pas PageImpl

0
pama