Frühjahr RestTemplate und generische Typen ParameterizedTypeReference Sammlungen wie List<T>

Einer Abstrakten controller-Klasse erfordert eine Liste von Objekten vom REST. Während mit Spring RestTemplate ist nicht seine Zuordnung zu Klasse erforderlich stattdessen gibt es zurück Verbunden HashMAp

 public List<T> restFindAll() {

    RestTemplate restTemplate = RestClient.build().restTemplate();
    ParameterizedTypeReference<List<T>>  parameterizedTypeReference = new ParameterizedTypeReference<List<T>>(){};
    String uri= BASE_URI +"/"+ getPath();

    ResponseEntity<List<T>> exchange = restTemplate.exchange(uri, HttpMethod.GET, null,parameterizedTypeReference);
    List<T> entities = exchange.getBody();
    //here entities are List<LinkedHashMap>
    return entities;

}

Wenn ich,

ParameterizedTypeReference<List<AttributeInfo>>  parameterizedTypeReference = 
    new ParameterizedTypeReference<List<AttributeInfo>>(){};
    ResponseEntity<List<AttributeInfo>> exchange =
  restTemplate.exchange(uri, HttpMethod.GET, null,parameterizedTypeReference);

Funktioniert es einwandfrei. Aber können nicht in allen Unterklassen, jede andere Lösung.

InformationsquelleAutor vels4j | 2016-04-28
  1. 23

    Ich habe gearbeitet um dieses mit der folgenden generischen Methode:

    public <T> List<T> exchangeAsList(String uri, ParameterizedTypeReference<List<T>> responseType) {
    return restTemplate.exchange(uri, HttpMethod.GET, null, responseType).getBody();
}

    Dann könnte ich rufen:

    List<MyDto> dtoList = this.exchangeAsList("http://my/url", new ParameterizedTypeReference<List<MyDto>>() {});

    Diese haben Last meiner Anrufer mit, dass Sie angeben, die ParameterizedTypeReference beim aufrufen, aber bedeutete, dass ich nicht haben, um zu halten ein statisches mapping von Typen wie in vels4j Antwort 

    InformationsquelleAutor Rossiar
  2. 8

    Konnte nicht finden, eine Lösung von Frühling, deshalb habe ich es getan mit ParameterizedTypeReference im HashMap wie 

     public final static HashMap<Class,ParameterizedTypeReference> paramTypeRefMap = new HashMap() ;
 static {
    paramTypeRefMap.put(AttributeDefinition.class, new ParameterizedTypeReference<List<AttributeDefinition>>(){} );
    paramTypeRefMap.put(AttributeInfo.class, new ParameterizedTypeReference<List<AttributeInfo>>(){} );
 }

    und verwendet es 

    ParameterizedTypeReference parameterizedTypeReference = paramTypeRefMap.get(requiredClass);
ResponseEntity<List> exchange = restTemplate.exchange(uri, HttpMethod.POST, entity, parameterizedTypeReference);
    • Die Methode exchange(String, HttpMethod, HttpEntity<?>, Class<T>, Objekt...) in der Art RestTemplate ist nicht anwendbar für die Argumente (String, HttpMethod, HttpEntity<LodgingAvailabilityRequest>, ParameterizedTypeReference<Liste<DXARoom>) hat es wirklich funktioniert für Sie ?
    InformationsquelleAutor vels4j
  3. 1

    Mit ParameterizedTypeReference für eine List<Domain>, wenn Domäne ist eine explizite Klasse, dass ParameterizedTypeReference gut funktioniert, wie hier:

    @Override
public List<Person> listAll() throws Exception {
    ResponseEntity<List<E>> response = restTemplate.exchange("http://example.com/person/", HttpMethod.GET, null,
            new ParameterizedTypeReference<List<Person>>() {});
    return response.getBody();
}

    Jedoch, wenn eine Methode listAll verwendet in generic Geschmack, diese Liste sollte parametrisierte selbst. Der beste Weg den ich gefunden ist:

    public abstract class WebServiceImpl<E> implements BaseService<E> {

    private Class<E> entityClass;

    @SuppressWarnings("unchecked")
    public WebServiceImpl() {
        this.entityClass = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass())
            .getActualTypeArguments()[0];
    }


    @Override
    public List<E> listAll() throws Exception {
        ResponseEntity<List<E>> response =  restTemplate.exchange("http://example.com/person/", HttpMethod.GET, null,
                new ParameterizedTypeReference<List<E>>() {
                    @Override
                    public Type getType() {
                        Type type = super.getType();
                        if (type instanceof ParameterizedType) {
                            Type[] responseWrapperActualTypes = { entityClass };
                            ParameterizedType responseWrapperType = new ParameterizedTypeImpl(List.class,
                                    responseWrapperActualTypes, null);
                            return responseWrapperType;
                        }
                        return type;
                    }
                });
        return response.getBody();
    }
}
    • Dies ist eine schöne Lösung für das typisierte Sammlungen, wenn die entity-Klasse wird nur als parameter übergeben, z.B. bei der Implementierung von spring-data RepositoryQuery. Danke!
    • Und anstatt Sonne internen APIs (ParameterizedTypeImpl), könnten Sie auch einen Blick auf commons-lang3 ist TypeUtils.
    InformationsquelleAutor Moesio
  4. 0

    Die einfachste Lösung für mich ist, um ein Objekt definieren MyOperationResult mit der Liste, die Sie erwarten, als Feld-und verwenden Sie restTemplate.getForObject um dieses Ergebnis zu erzielen.

    InformationsquelleAutor JRA_TLL
Schreibe einen Kommentar