Pobierz listę obiektów JSON za pomocą Spring RestTemplate

Mam dwa pytania:

• Jak zmapować listę obiektów JSON przy użyciu Spring RestTemplate.
• Jak mapować zagnieżdżone obiekty JSON.

Staram się konsumować https://bitpay.com/api/rates , postępując zgodnie z samouczkiem z http://spring.io/guides/gs/consuming-rest/ .

Może w ten sposób ...

ResponseEntity<Object[]> responseEntity = restTemplate.getForEntity(urlGETList, Object[].class);
Object[] objects = responseEntity.getBody();
MediaType contentType = responseEntity.getHeaders().getContentType();
HttpStatus statusCode = responseEntity.getStatusCode();

Kod kontrolera dla RequestMapping

@RequestMapping(value="/Object/getList/", method=RequestMethod.GET)
public @ResponseBody List<Object> findAllObjects() {

    List<Object> objects = new ArrayList<Object>();
    return objects;
}

ResponseEntityjest rozszerzeniem tego, HttpEntityktóry dodaje HttpStatuskod statusu. Używany RestTemplaterównież w @Controllermetodach. W RestTemplatetej klasie zwracany jest przez getForEntity()i exchange().

Najpierw zdefiniuj obiekt, aby zatrzymać byt wracający do tablicy. Np

@JsonIgnoreProperties(ignoreUnknown = true)
public class Rate {
    private String name;
    private String code;
    private Double rate;
    // add getters and setters
}

Następnie możesz skorzystać z usługi i uzyskać silnie wpisaną listę za pośrednictwem:

ResponseEntity<List<Rate>> rateResponse =
        restTemplate.exchange("https://bitpay.com/api/rates",
                    HttpMethod.GET, null, new ParameterizedTypeReference<List<Rate>>() {
            });
List<Rate> rates = rateResponse.getBody();

Inne powyższe rozwiązania również będą działać, ale lubię odzyskiwać mocno wpisaną listę zamiast Object [].

Dla mnie to zadziałało

Object[] forNow = template.getForObject("URL", Object[].class);
    searchList= Arrays.asList(forNow);

Gdzie Object to klasa, którą chcesz

Po wielu testach jest to najlepszy sposób, jaki znalazłem :)

Set<User> test = httpService.get(url).toResponseSet(User[].class);

Wszystko czego potrzebujesz

public <T> Set<T> toResponseSet(Class<T[]> setType) {
    HttpEntity<?> body = new HttpEntity<>(objectBody, headers);
    ResponseEntity<T[]> response = template.exchange(url, method, body, setType);
    return Sets.newHashSet(response.getBody());
}

Moim wielkim problemem tutaj było zbudowanie struktury Object wymaganej do dopasowania RestTemplate do kompatybilnej klasy. Na szczęście znalazłem http://www.jsonschema2pojo.org/ (pobierz odpowiedź JSON w przeglądarce i użyj jej jako danych wejściowych) i nie mogę tego wystarczająco polecić!

faktycznie opracowałem coś funkcjonalnego dla jednego z moich projektów i oto kod:

/**
 * @param url             is the URI address of the WebService
 * @param parameterObject the object where all parameters are passed.
 * @param returnType      the return type you are expecting. Exemple : someClass.class
 */

public static <T> T getObject(String url, Object parameterObject, Class<T> returnType) {
    try {
        ResponseEntity<T> res;
        ObjectMapper mapper = new ObjectMapper();
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));
        ((SimpleClientHttpRequestFactory) restTemplate.getRequestFactory()).setConnectTimeout(2000);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<T> entity = new HttpEntity<T>((T) parameterObject, headers);
        String json = mapper.writeValueAsString(restTemplate.exchange(url, org.springframework.http.HttpMethod.POST, entity, returnType).getBody());
        return new Gson().fromJson(json, returnType);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

/**
 * @param url             is the URI address of the WebService
 * @param parameterObject the object where all parameters are passed.
 * @param returnType      the type of the returned object. Must be an array. Exemple : someClass[].class
 */
public static <T> List<T> getListOfObjects(String url, Object parameterObject, Class<T[]> returnType) {
    try {
        ObjectMapper mapper = new ObjectMapper();
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));
        ((SimpleClientHttpRequestFactory) restTemplate.getRequestFactory()).setConnectTimeout(2000);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<T> entity = new HttpEntity<T>((T) parameterObject, headers);
        ResponseEntity<Object[]> results = restTemplate.exchange(url, org.springframework.http.HttpMethod.POST, entity, Object[].class);
        String json = mapper.writeValueAsString(results.getBody());
        T[] arr = new Gson().fromJson(json, returnType);
        return Arrays.asList(arr);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

Mam nadzieję, że to komuś pomoże!

Jeśli wolisz listę obiektów, możesz to zrobić w następujący sposób:

public <T> List<T> getApi(final String path, final HttpMethod method) {     
    final RestTemplate restTemplate = new RestTemplate();
    final ResponseEntity<List<T>> response = restTemplate.exchange(
      path,
      method,
      null,
      new ParameterizedTypeReference<List<T>>(){});
    List<T> list = response.getBody();
    return list;
}

I użyj go w ten sposób:

 List<SomeObject> list = someService.getApi("http://localhost:8080/some/api",HttpMethod.GET);

Wyjaśnienia dotyczące powyższego można znaleźć tutaj ( https://www.baeldung.com/spring-rest-template-list ), a ich parafrazę podano poniżej.

„W powyższym kodzie dzieje się kilka rzeczy. Po pierwsze, używamy ResponseEntity jako naszego typu zwracanego, używając go do zawijania listy obiektów, których naprawdę chcemy. Po drugie, wywołujemy RestTemplate.exchange () zamiast getForObject () .

Jest to najbardziej ogólny sposób użycia RestTemplate. Wymaga od nas określenia metody HTTP, opcjonalnego treści żądania i typu odpowiedzi. W tym przypadku używamy anonimowej podklasy ParameterizedTypeReference dla typu odpowiedzi.

Ta ostatnia część pozwala nam przekonwertować odpowiedź JSON na listę obiektów odpowiedniego typu. Kiedy tworzymy anonimową podklasę ParameterizedTypeReference, wykorzystuje ona refleksję do przechwytywania informacji o typie klasy, na który chcemy przekonwertować naszą odpowiedź.

Przechowuje te informacje za pomocą obiektu Type w Javie i nie musimy się już martwić o usunięcie typu ”.

Rozważ zobacz tę odpowiedź, szczególnie jeśli chcesz używać ogólnych w List Spring RestTemplate i ogólnych typów ParameterizedTypeReference, takich jak List <T>

Możesz utworzyć POJO dla każdego wpisu, np.

class BitPay{
private String code;
private String name;
private double rate;
}

następnie używając ParameterizedTypeReference z listy BitPay możesz użyć jako:

RestTemplate restTemplate = new RestTemplate();
ResponseEntity<List<Employee>> response = restTemplate.exchange(
  "https://bitpay.com/api/rates",
  HttpMethod.GET,
  null,
  new ParameterizedTypeReference<List<BitPay>>(){});
List<Employee> employees = response.getBody();

Znalazłem obejście tego postu https://jira.spring.io/browse/SPR-8263 .

Na podstawie tego postu możesz zwrócić taką wpisaną listę:

ResponseEntity<? extends ArrayList<User>> responseEntity = restTemplate.getForEntity(restEndPointUrl, (Class<? extends ArrayList<User>>)ArrayList.class, userId);