streamalism.org

1. Oversigt

I denne vejledning illustrerer vi den brede vifte af operationer, hvor Spring REST-klienten - RestTemplate - kan bruges og bruges godt.

For API-siden af ​​alle eksempler kører vi RESTful-tjenesten herfra.

2. Meddelelse om afskrivning

Fra og med Spring Framework 5 introducerede Spring sammen med WebFlux-stakken en ny HTTP-klient kaldet Webklient.

Webklient er en moderne, alternativ HTTP-klient til RestTemplate. Ikke kun giver det en traditionel synkron API, men den understøtter også en effektiv ikke-blokering og asynkron tilgang.

Når det er sagt, hvis vi udvikler nye applikationer eller migrerer en gammel, det er en god ide at bruge Webklient. Bevæger sig fremad, RestTemplate bliver udfaset i fremtidige versioner.

3. Brug GET til at hente ressourcer

3.1. Få almindelig JSON

Lad os starte simpelt og tale om GET-anmodninger med et hurtigt eksempel ved hjælp af getForEntity () API:

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

Bemærk, at vi har fuld adgang til HTTP-svaret, så vi kan gøre ting som at kontrollere statuskoden for at sikre, at operationen var vellykket eller arbejde med selve reaktionens hoveddel:

ObjectMapper-kortlægger = ny ObjectMapper (); JsonNode rod = mapper.readTree (respons.getBody ()); JsonNode navn = root.path ("navn"); assertThat (name.asText (), notNullValue ());

Vi arbejder med responsorganet som en standardstreng her og bruger Jackson (og JSON-nodestrukturen, som Jackson giver) til at verificere nogle detaljer.

3.2. Henter POJO i stedet for JSON

Vi kan også kortlægge svaret direkte til en ressource-DTO:

offentlig klasse Foo implementerer Serialiserbar {privat lang id; privat strengnavn; // standard getters og setter}

Nu kan vi simpelthen bruge getForObject API i skabelonen:

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

4. Brug HEAD til at hente overskrifter

Lad os nu se hurtigt på brugen af ​​HEAD, inden vi går videre til de mere almindelige metoder.

Vi skal bruge headForHeaders () API her:

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

5. Brug POST til at oprette en ressource

For at oprette en ny ressource i API'et kan vi gøre god brug af postForLocation (), postForObject () eller postForEntity () API'er.

Den første returnerer URI for den nyoprettede ressource, mens den anden returnerer selve ressourcen.

5.1. Det postForObject () API

RestTemplate restTemplate = ny RestTemplate (); HttpEntity-anmodning = ny HttpEntity (ny Foo ("bar")); Foo foo = restTemplate.postForObject (fooResourceUrl, anmodning, Foo.class); hævder, at (foo, notNullValue ()); assertThat (foo.getName (), er ("bar"));

5.2. Det postForLocation () API

Lad os ligeledes se på operationen, der i stedet for at returnere den fulde ressource, bare returnerer Beliggenhed af den nyoprettede ressource:

HttpEntity anmodning = ny HttpEntity (ny Foo ("bar")); URI-placering = restTemplate .postForLocation (fooResourceUrl, anmodning); assertThat (location, notNullValue ());

5.3. Det udveksling() API

Lad os se på, hvordan man laver en POST med det mere generiske udveksling API:

RestTemplate restTemplate = ny RestTemplate (); HttpEntity-anmodning = ny HttpEntity (ny Foo ("bar")); ResponseEntity response = restTemplate .exchange (fooResourceUrl, HttpMethod.POST, anmodning, Foo.class); assertThat (respons.getStatusCode (), er (HttpStatus.CREATED)); Foo foo = respons.getBody (); hævder, at (foo, notNullValue ()); assertThat (foo.getName (), er ("bar")); 

5.4. Indsend formulardata

Lad os derefter se på, hvordan du indsender en formular ved hjælp af POST-metoden.

Først skal vi indstille Indholdstype header til application / x-www-form-urlencoded.

Dette sikrer, at en stor forespørgselsstreng kan sendes til serveren, der indeholder navn / værdipar adskilt af &:

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

Vi kan pakke formvariablerne ind i en LinkedMultiValueMap:

MultiValueMap-kort = nyt LinkedMultiValueMap (); map.add ("id", "1");

Næste, vi bygger anmodningen ved hjælp af en HttpEntity eksempel:

HttpEntity anmodning = ny HttpEntity (kort, overskrifter);

Endelig kan vi oprette forbindelse til REST-tjenesten ved at ringe restTemplate.postForEntity () på slutpunktet: /foos/form

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

6. Brug OPTIONS for at få tilladte operationer

Dernæst vil vi se hurtigt på at bruge en OPTIONS-anmodning og udforske de tilladte operationer på en bestemt URI ved hjælp af denne form for anmodning; API'en er optionsForAllow:

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

7. Brug PUT til at opdatere en ressource

Dernæst begynder vi at se på PUT og mere specifikt udveksling() API til denne operation, da template.put API er ret ligetil.

7.1. Enkel SÆTTE Med udveksling()

Vi starter med en simpel PUT-operation mod API'en - og husk, at operationen ikke returnerer et organ tilbage til klienten:

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

7.2. PUT med udveksling() og en anmodning om tilbagekaldelse

Dernæst bruger vi en anmodning om tilbagekald til at udstede en PUT.

Lad os sørge for, at vi forbereder tilbagekaldet, hvor vi kan indstille alle de overskrifter, vi har brug for, samt et anmodningsorgan:

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

Dernæst opretter vi ressourcen med en POST-anmodning:

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

Og så opdaterer vi ressourcen:

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. Brug SLET for at fjerne en ressource

For at fjerne en eksisterende ressource bruger vi hurtig slet () API:

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

9. Konfigurer timeout

Vi kan konfigurere RestTemplate til timeout ved blot at bruge ClientHttpRequestFactory:

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

Og vi kan bruge HttpClient for yderligere konfigurationsmuligheder:

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. Konklusion

I denne artikel gik vi over de vigtigste HTTP-verb ved hjælp af RestTemplate at orkestrere anmodninger ved hjælp af alle disse.

Hvis du vil grave i, hvordan du udfører godkendelse med skabelonen, skal du tjekke vores artikel om Basic Auth med RestTemplate.

Implementeringen af ​​alle disse eksempler og kodestykker findes på GitHub.