streamalism.org

1. Oversikt

I denne opplæringen skal vi illustrere det brede spekteret av operasjoner der Spring REST-klienten - RestTemplate - kan brukes, og brukes godt.

For API-siden av alle eksemplene kjører vi RESTful-tjenesten herfra.

2. Merknad om avskrivning

Fra og med Spring Framework 5 introduserte Spring, sammen med WebFlux-stakken, en ny HTTP-klient kalt WebClient.

WebClient er en moderne, alternativ HTTP-klient til RestTemplate. Ikke bare gir den en tradisjonell synkron API, men den støtter også en effektiv ikke-blokkerende og asynkron tilnærming.

Når det er sagt, hvis vi utvikler nye applikasjoner eller migrerer en gammel, det er en god idé å bruke WebClient. Går videre, RestTemplate blir avviklet i fremtidige versjoner.

3. Bruk GET for å hente ressurser

3.1. Få vanlig JSON

La oss starte enkelt og snakke om GET-forespørsler, med et raskt eksempel ved hjelp av getForEntity () API:

RestTemplate restTemplate = ny RestTemplate (); String fooResourceUrl = "// localhost: 8080 / spring-rest / foos"; ResponseEntity response = restTemplate.getForEntity (fooResourceUrl + "/ 1", String.class); assertThat (respons.getStatusCode (), equalTo (HttpStatus.OK));

Legg merke til at vi har full tilgang til HTTP-responsen, slik at vi kan gjøre ting som å sjekke statuskoden for å forsikre oss om at operasjonen var vellykket eller jobbe med selve responsen:

ObjectMapper mapper = ny ObjectMapper (); JsonNode rot = mapper.readTree (respons.getBody ()); JsonNode navn = root.path ("navn"); assertThat (name.asText (), notNullValue ());

Vi jobber med responsorganet som en standard streng her og bruker Jackson (og JSON-nodestrukturen som Jackson gir) for å verifisere noen detaljer.

3.2. Henter POJO i stedet for JSON

Vi kan også kartlegge svaret direkte til en ressurs-DTO:

offentlig klasse Foo implementerer Serializable {privat lang id; privat strengnavn; // standard getters og setters}

Nå kan vi bare bruke getForObject API i malen:

Foo foo = restTemplate .getForObject (fooResourceUrl + "/ 1", Foo.class); assertThat (foo.getName (), notNullValue ()); assertThat (foo.getId (), er (1L));

4. Bruk HEAD for å hente overskrifter

La oss nå se raskt på bruk av HEAD før vi går videre til de vanligste metodene.

Vi skal bruke headForHeaders () API her:

HttpHeaders httpHeaders = restTemplate.headForHeaders (fooResourceUrl); assertTrue (httpHeaders.getContentType (). inkluderer (MediaType.APPLICATION_JSON));

5. Bruk POST til å opprette en ressurs

For å opprette en ny ressurs i API-et, kan vi gjøre god bruk av postForLocation (), postForObject () eller postForEntity () APIer.

Den første returnerer URI for den nyopprettede ressursen, mens den andre returnerer selve ressursen.

5.1. De postForObject () API

RestTemplate restTemplate = ny RestTemplate (); HttpEntity-forespørsel = ny HttpEntity (ny Foo ("bar")); Foo foo = restTemplate.postForObject (fooResourceUrl, forespørsel, Foo.class); assertThat (foo, notNullValue ()); assertThat (foo.getName (), er ("bar"));

5.2. De postForLocation () API

På samme måte, la oss ta en titt på operasjonen som i stedet for å returnere hele ressursen, bare returnerer plassering av den nyopprettede ressursen:

HttpEntity-forespørsel = ny HttpEntity (ny Foo ("bar")); URI-plassering = restTemplate .postForLocation (fooResourceUrl, forespørsel); assertThat (location, notNullValue ());

5.3. De Utveksling() API

La oss ta en titt på hvordan du gjør en POST med det mer generiske Utveksling API:

RestTemplate restTemplate = ny RestTemplate (); HttpEntity-forespørsel = ny HttpEntity (ny Foo ("bar")); ResponseEntity response = restTemplate .exchange (fooResourceUrl, HttpMethod.POST, forespørsel, Foo.class); assertThat (respons.getStatusCode (), er (HttpStatus.CREATED)); Foo foo = respons.getBody (); assertThat (foo, notNullValue ()); assertThat (foo.getName (), er ("bar")); 

5.4. Send inn skjemadata

La oss deretter se på hvordan du sender inn et skjema ved hjelp av POST-metoden.

Først må vi stille inn Innholdstype topptekst til application / x-www-form-urlencoded.

Dette sørger for at en stor spørringsstreng kan sendes til serveren, som inneholder navn / verdipar atskilt med &:

HttpHeaders headers = nye HttpHeaders (); headers.setContentType (MediaType.APPLICATION_FORM_URLENCODED);

Vi kan pakke inn formvariablene i en LinkedMultiValueMap:

MultiValueMap-kart = nytt LinkedMultiValueMap (); map.add ("id", "1");

Neste, vi bygger forespørselen ved hjelp av en HttpEntity forekomst:

HttpEntity forespørsel = ny HttpEntity (kart, overskrifter);

Til slutt kan vi koble til REST-tjenesten ved å ringe restTemplate.postForEntity () på endepunktet: /foos/ skjema

ResponseEntity response = restTemplate.postForEntity (fooResourceUrl + "/ form", forespørsel, String.class); assertThat (respons.getStatusCode (), er (HttpStatus.CREATED));

6. Bruk ALTERNATIVER for å få tillatt drift

Deretter skal vi se raskt på å bruke en OPTIONS-forespørsel og utforske de tillatte operasjonene på en bestemt URI ved hjelp av denne typen forespørsel; API er optionsForAllow:

Sett optionsForAllow = restTemplate.optionsForAllow (fooResourceUrl); HttpMethod [] supportsMethods = {HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE}; assertTrue (optionsForAllow.containsAll (Arrays.asList (supportedMethods)));

7. Bruk PUT for å oppdatere en ressurs

Deretter begynner vi å se på PUT og nærmere bestemt Utveksling() API for denne operasjonen, siden template.put API er ganske grei.

7.1. Enkel SETTE Med Utveksling()

Vi starter med en enkel PUT-operasjon mot API - og husk at operasjonen ikke returnerer en kropp tilbake til klienten:

Foo updatedInstance = new Foo ("newName"); updatedInstance.setId (createResponse.getBody (). getId ()); Streng resourceUrl = fooResourceUrl + '/' + createResponse.getBody (). GetId (); HttpEntity requestUpdate = ny HttpEntity (updatedInstance, headers); template.exchange (resourceUrl, HttpMethod.PUT, requestUpdate, Void.class);

7.2. PUT med Utveksling() og en forespørsel om tilbakeringing

Deretter skal vi bruke en tilbakeringing forespørsel for å utstede en PUT.

La oss sørge for at vi forbereder tilbakeringingen, hvor vi kan angi alle overskriftene vi trenger, samt et forespørselsorgan:

RequestCallback requestCallback (final Foo updatedInstance) {return clientHttpRequest -> {ObjectMapper mapper = new ObjectMapper (); mapper.writeValue (clientHttpRequest.getBody (), updatedInstance); clientHttpRequest.getHeaders (). legg til (HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE); clientHttpRequest.getHeaders (). legg til (HttpHeaders.AUTHORIZATION, "Basic" + getBase64EncodedLogPass ()); }; }

Deretter oppretter vi ressursen med en POST-forespørsel:

ResponseEntity response = restTemplate .exchange (fooResourceUrl, HttpMethod.POST, forespørsel, Foo.class); assertThat (respons.getStatusCode (), er (HttpStatus.CREATED));

Og så oppdaterer vi ressursen:

Foo updatedInstance = new Foo ("newName"); updatedInstance.setId (respons.getBody (). getId ()); Streng resourceUrl = fooResourceUrl + '/' + respons.getBody (). GetId (); restTemplate.execute (resourceUrl, HttpMethod.PUT, requestCallback (updatedInstance), clientHttpResponse -> null);

8. Bruk SLETT for å fjerne en ressurs

For å fjerne en eksisterende ressurs, bruker vi raskt slett () API:

Streng entityUrl = fooResourceUrl + "/" + eksisterendeResource.getId (); restTemplate.delete (entityUrl); 

9. Konfigurer tidsavbrudd

Vi kan konfigurere RestTemplate å avbryte ved å bare bruke ClientHttpRequestFactory:

RestTemplate restTemplate = ny RestTemplate (getClientHttpRequestFactory ()); privat ClientHttpRequestFactory getClientHttpRequestFactory () {int timeout = 5000; HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = ny HttpComponentsClientHttpRequestFactory (); clientHttpRequestFactory.setConnectTimeout (timeout); returner klientHttpRequestFactory; }

Og vi kan bruke HttpClient for ytterligere konfigurasjonsalternativer:

privat ClientHttpRequestFactory getClientHttpRequestFactory () {int timeout = 5000; RequestConfig config = RequestConfig.custom () .setConnectTimeout (timeout) .setConnectionRequestTimeout (timeout) .setSocketTimeout (timeout) .build (); CloseableHttpClient client = HttpClientBuilder .create () .setDefaultRequestConfig (config) .build (); returner nye HttpComponentsClientHttpRequestFactory (klient); }

10. Konklusjon

I denne artikkelen gikk vi over de viktigste HTTP-verbene ved hjelp av RestTemplate å orkestrere forespørsler ved å bruke alle disse.

Hvis du vil grave i hvordan du gjør autentisering med malen, kan du sjekke ut artikkelen vår om Basic Auth with RestTemplate.

Implementeringen av alle disse eksemplene og kodebiter finner du på GitHub.