streamalism.org

1. Overzicht

In deze tutorial gaan we het brede scala aan bewerkingen illustreren waarbij de Spring REST Client - RestTemplate - kan worden gebruikt, en goed gebruikt.

Voor de API-kant van alle voorbeelden voeren we de RESTful-service vanaf hier uit.

2. Kennisgeving van beëindiging

Vanaf Spring Framework 5 introduceerde Spring naast de WebFlux-stack een nieuwe HTTP-client met de naam Web cliënt.

Web cliënt is een moderne, alternatieve HTTP-client voor RestTemplate. Het biedt niet alleen een traditionele synchrone API, maar het ondersteunt ook een efficiënte niet-blokkerende en asynchrone aanpak.

Dat gezegd hebbende, als we nieuwe applicaties ontwikkelen of een oude migreren, het is een goed idee om te gebruiken Web cliënt. Vooruit gaan, RestTemplate wordt in toekomstige versies afgeschaft.

3. Gebruik GET om bronnen op te halen

3.1. Krijg gewone JSON

Laten we eenvoudig beginnen en praten over GET-verzoeken, met een snel voorbeeld met behulp van de getForEntity () API:

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

Merk op dat we volledige toegang hebben tot het HTTP-antwoord, zodat we dingen kunnen doen zoals de statuscode controleren om er zeker van te zijn dat de bewerking is geslaagd of werken met de daadwerkelijke hoofdtekst van het antwoord:

ObjectMapper-mapper = nieuwe ObjectMapper (); JsonNode root = mapper.readTree (response.getBody ()); JsonNode naam = root.path ("naam"); assertThat (name.asText (), notNullValue ());

We werken hier met de responsbody als een standaard String en gebruiken Jackson (en de JSON-knooppuntstructuur die Jackson biedt) om enkele details te verifiëren.

3.2. POJO ophalen in plaats van JSON

We kunnen de respons ook rechtstreeks toewijzen aan een resource-DTO:

openbare klasse Foo implementeert Serializable {privé lange id; private String naam; // standaard getters en setters}

Nu kunnen we gewoon de getForObject API in de sjabloon:

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

4. Gebruik HEAD om kopteksten op te halen

Laten we nu eens kort kijken naar het gebruik van HEAD voordat we verder gaan met de meer gebruikelijke methoden.

We gaan de headForHeaders () API hier:

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

5. Gebruik POST om een ​​bron te maken

Om een ​​nieuwe Resource in de API aan te maken, kunnen we goed gebruik maken van de postForLocation (), postForObject () of postForEntity () API's.

De eerste retourneert de URI van de nieuw gemaakte resource, terwijl de tweede de resource zelf retourneert.

5.1. De postForObject () API

RestTemplate restTemplate = nieuwe RestTemplate (); HttpEntity request = nieuwe HttpEntity (nieuwe Foo ("bar")); Foo foo = restTemplate.postForObject (fooResourceUrl, verzoek, Foo.class); assertThat (foo, notNullValue ()); assertThat (foo.getName (), is ("bar"));

5.2. De postForLocation () API

Laten we op dezelfde manier eens kijken naar de bewerking die in plaats van de volledige resource te retourneren, alleen de Plaats van die nieuw gecreëerde bron:

HttpEntity request = nieuwe HttpEntity (nieuwe Foo ("bar")); URI-locatie = restTemplate .postForLocation (fooResourceUrl, verzoek); assertThat (locatie, notNullValue ());

5.3. De uitwisseling() API

Laten we eens kijken hoe u een POST kunt doen met de meer algemene uitwisseling API:

RestTemplate restTemplate = nieuwe RestTemplate (); HttpEntity request = nieuwe HttpEntity (nieuwe Foo ("bar")); ResponseEntity response = restTemplate .exchange (fooResourceUrl, HttpMethod.POST, request, Foo.class); assertThat (response.getStatusCode (), is (HttpStatus.CREATED)); Foo foo = response.getBody (); assertThat (foo, notNullValue ()); assertThat (foo.getName (), is ("bar")); 

5.4. Formuliergegevens indienen

Laten we vervolgens kijken hoe we een formulier kunnen indienen met behulp van de POST-methode.

Eerst moeten we de Inhoudstype koptekst naar application / x-www-form-urlencoded.

Dit zorgt ervoor dat er een grote querytekenreeks naar de server kan worden gestuurd, met naam / waarde-paren gescheiden door &:

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

We kunnen de formuliervariabelen in een LinkedMultiValueMap:

MultiValueMap-kaart = nieuwe LinkedMultiValueMap (); map.add ("id", "1");

De volgende, we bouwen het verzoek met behulp van een HttpEntity voorbeeld:

HttpEntity request = nieuwe HttpEntity (map, headers);

Ten slotte kunnen we verbinding maken met de REST-service door te bellen restTemplate.postForEntity () op het eindpunt: /foos/het formulier

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

6. Gebruik OPTIES om toegestane bewerkingen te krijgen

Vervolgens gaan we snel kijken naar het gebruik van een OPTIONS-verzoek en het verkennen van de toegestane bewerkingen op een specifieke URI met behulp van dit soort verzoek; de API is optionsForAllow:

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

7. Gebruik PUT om een ​​bron bij te werken

Vervolgens gaan we kijken naar PUT en meer specifiek naar het uitwisseling() API voor deze bewerking, aangezien de template.put API is vrij eenvoudig.

7.1. Gemakkelijk LEGGEN Met uitwisseling()

We beginnen met een eenvoudige PUT-bewerking tegen de API - en onthoud dat de bewerking geen body terugstuurt naar de client:

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

7.2. Plaatsen met uitwisseling() en een verzoek om terug te bellen

Vervolgens gaan we een callback-verzoek gebruiken om een ​​PUT uit te voeren.

Laten we ervoor zorgen dat we de callback voorbereiden, waar we alle headers kunnen instellen die we nodig hebben, evenals een verzoektekst:

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

Vervolgens maken we de bron met een POST-verzoek:

ResponseEntity response = restTemplate .exchange (fooResourceUrl, HttpMethod.POST, request, Foo.class); assertThat (response.getStatusCode (), is (HttpStatus.CREATED));

En dan werken we de bron bij:

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

8. Gebruik DELETE om een ​​bron te verwijderen

Om een ​​bestaande bron te verwijderen, maken we snel gebruik van de verwijderen () API:

String entityUrl = fooResourceUrl + "/" + bestaandeResource.getId (); restTemplate.delete (entityUrl); 

9. Configureer Time-out

We kunnen configureren RestTemplate time-out door simpelweg te gebruiken ClientHttpRequestFactory:

RestTemplate restTemplate = nieuwe RestTemplate (getClientHttpRequestFactory ()); private ClientHttpRequestFactory getClientHttpRequestFactory () {int time-out = 5000; HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = nieuwe HttpComponentsClientHttpRequestFactory (); clientHttpRequestFactory.setConnectTimeout (time-out); retourneer clientHttpRequestFactory; }

En we kunnen gebruiken HttpClient voor verdere configuratie-opties:

private ClientHttpRequestFactory getClientHttpRequestFactory () {int time-out = 5000; RequestConfig config = RequestConfig.custom () .setConnectTimeout (time-out) .setConnectionRequestTimeout (time-out) .setSocketTimeout (time-out) .build (); CloseableHttpClient client = HttpClientBuilder .create () .setDefaultRequestConfig (config) .build (); retourneer nieuwe HttpComponentsClientHttpRequestFactory (client); }

10. Conclusie

In dit artikel hebben we de belangrijkste HTTP-werkwoorden besproken met RestTemplate om verzoeken te orkestreren met behulp van al deze.

Als je wilt onderzoeken hoe je authenticatie met de sjabloon kunt doen, bekijk dan ons artikel over Basic Auth met RestTemplate.

De implementatie van al deze voorbeelden en codefragmenten is te vinden op GitHub.