streamalism.org

1. Prehľad

V tomto výučbe si ukážeme široké spektrum operácií, kde klient Spring REST - RestTemplate - dá sa použiť a dobre sa používa.

Na strane API všetkých príkladov budeme odtiaľto spúšťať službu RESTful.

2. Oznámenie o ukončení podpory

Od Spring Framework 5 predstavil Spring popri zásobníku WebFlux nového HTTP klienta s názvom Webový klient.

Webový klient je moderný alternatívny klient HTTP k RestTemplate. Poskytuje nielen tradičné synchrónne API, ale podporuje aj efektívny neblokujúci a asynchrónny prístup.

To znamená, že ak vyvíjame nové aplikácie alebo migrujeme starú, je to dobrý nápad použiť Webový klient. Hýbať sa vpred, RestTemplate bude v budúcich verziách zastaraná.

3. Použite GET na získanie zdrojov

3.1. Získajte obyčajný JSON

Začnime jednoducho a hovorme o požiadavkách GET rýchly príklad pomocou getForEntity () API:

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

Všimnite si, že máme plný prístup k odpovedi HTTP, takže môžeme robiť veci, ako je kontrola stavového kódu, aby sme sa ubezpečili, že operácia bola úspešná, alebo práca so skutočným textom odpovede:

ObjectMapper mapovač = nový ObjectMapper (); Root JsonNode = mapper.readTree (response.getBody ()); JsonNode name = root.path ("meno"); assertThat (name.asText (), notNullValue ());

Pracujeme s telom odpovede ako so štandardným reťazcom a na overenie niektorých podrobností používame Jackson (a štruktúru uzlov JSON, ktorú Jackson poskytuje).

3.2. Načítanie POJO namiesto JSON

Môžeme tiež namapovať odpoveď priamo na DTO zdroja:

public class Foo implementuje Serializable {private long id; súkromné ​​meno reťazca; // štandardné getre a setre}

Teraz môžeme jednoducho použiť getForObject API v šablóne:

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

4. Na načítanie hlavičiek použite HEAD

Poďme sa teraz rýchlo pozrieť na používanie HEAD, než prejdeme k bežnejším metódam.

Budeme používať headForHeaders () API tu:

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

5. Použite POST na vytvorenie zdroja

Na vytvorenie nového zdroja v API môžeme dobre využívať postForLocation (), postForObject () alebo postForEntity () API.

Prvý vráti URI novovytvoreného zdroja, zatiaľ čo druhý vráti samotný zdroj.

5.1. The postForObject () API

RestTemplate restTemplate = nový RestTemplate (); HttpEntity request = new HttpEntity (new Foo ("bar")); Foo foo = restTemplate.postForObject (fooResourceUrl, požiadavka, Foo.class); assertThat (foo, notNullValue ()); assertThat (foo.getName (), is ("bar"));

5.2. The postForLocation () API

Podobne sa pozrime na operáciu, ktorá namiesto vrátenia celého zdroja vráti iba znak Poloha z tohto novovytvoreného zdroja:

HttpEntity request = new HttpEntity (new Foo ("bar")); URI umiestnenie = restTemplate .postForLocation (fooResourceUrl, požiadavka); assertThat (location, notNullValue ());

5.3. The výmena () API

Poďme sa pozrieť na to, ako urobiť POST s tým všeobecnejším výmena API:

RestTemplate restTemplate = nový RestTemplate (); HttpEntity request = new HttpEntity (new Foo ("bar")); ResponseEntity response = restTemplate .exchange (fooResourceUrl, HttpMethod.POST, požiadavka, Foo.class); assertThat (response.getStatusCode (), je (HttpStatus.CREATED)); Foo foo = response.getBody (); assertThat (foo, notNullValue ()); assertThat (foo.getName (), is ("bar")); 

5.4. Odošlite údaje formulára

Ďalej sa pozrime na to, ako odoslať formulár pomocou metódy POST.

Najskôr musíme nastaviť Druh obsahu hlavička do application / x-www-form-urlencoded.

To zaisťuje, že na server je možné odoslať veľký reťazec dotazu, ktorý obsahuje páry mien a hodnôt oddelené znakom &:

Hlavičky HttpHeaders = nové HttpHeaders (); headers.setContentType (MediaType.APPLICATION_FORM_URLENCODED);

Premenné formulára môžeme zabaliť do a LinkedMultiValueMap:

Mapa MultiValueMap = nová LinkedMultiValueMap (); map.add ("id", "1");

Ďalšie, staviame žiadosť pomocou HttpEntity inštancia:

HttpEntity požiadavka = nová HttpEntity (mapa, hlavičky);

Na záver sa môžeme pripojiť k službe REST zavolaním restTemplate.postForEntity () v koncovom bode: /foos/ forma

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

6. Použite MOŽNOSTI na získanie povolených operácií

Ďalej sa rýchlo pozrieme na použitie požiadavky OPTIONS a preskúmanie povolených operácií na konkrétnom URI pomocou tohto druhu žiadosti; API je optionsForAllow:

Nastaviť možnostiForAllow = restTemplate.optionsForAllow (fooResourceUrl); HttpMethod [] supportedMethods = {HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE}; assertTrue (optionsForAllow.containsAll (Arrays.asList (supportedMethods))));

7. Použite PUT na aktualizáciu zdroja

Ďalej sa začneme zaoberať PUT a konkrétnejšie výmena () API pre túto operáciu, pretože template.put API je dosť priame.

7.1. Jednoduché PUT S výmena ()

Začneme jednoduchou operáciou PUT proti API - a majte na pamäti, že operácia nevracia telo späť klientovi:

Foo updatedInstance = new Foo ("newName"); updatedInstance.setId (createResponse.getBody (). getId ()); Reťazec resourceUrl = fooResourceUrl + '/' + createResponse.getBody (). GetId (); HttpEntity requestUpdate = nový HttpEntity (updatedInstance, hlavičky); template.exchange (resourceUrl, HttpMethod.PUT, requestUpdate, Void.class);

7.2. Dajte s výmena () a Vyžiadajte si spätné volanie

Ďalej použijeme spätné volanie žiadosti na vydanie PUT.

Nezabudnite pripraviť spätné volanie, kde môžeme nastaviť všetky potrebné hlavičky, ako aj telo žiadosti:

RequestCallback requestCallback (konečné 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 ()); }; }

Ďalej vytvoríme Zdroj s požiadavkou POST:

ResponseEntity response = restTemplate .exchange (fooResourceUrl, HttpMethod.POST, požiadavka, Foo.class); assertThat (response.getStatusCode (), je (HttpStatus.CREATED));

A potom aktualizujeme zdroj:

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

8. Na odstránenie zdroja použite príkaz DELETE

Na odstránenie existujúceho zdroja rýchlo využijeme odstrániť () API:

Reťazec entityUrl = fooResourceUrl + "/" + existingResource.getId (); restTemplate.delete (entityUrl); 

9. Nakonfigurujte časový limit

Môžeme nakonfigurovať RestTemplate na oddychový čas jednoduchým použitím ClientHttpRequestFactory:

RestTemplate restTemplate = nový RestTemplate (getClientHttpRequestFactory ()); private ClientHttpRequestFactory getClientHttpRequestFactory () {int timeout = 5000; HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = nový HttpComponentsClientHttpRequestFactory (); clientHttpRequestFactory.setConnectTimeout (časový limit); vrátiť clientHttpRequestFactory; }

A môžeme použiť HttpClient pre ďalšie možnosti konfigurácie:

private ClientHttpRequestFactory getClientHttpRequestFactory () {int timeout = 5000; RequestConfig config = RequestConfig.custom () .setConnectTimeout (časový limit) .setConnectionRequestTimeout (časový limit) .setSocketTimeout (časový limit) .build (); CloseableHttpClient client = HttpClientBuilder .create () .setDefaultRequestConfig (config) .build (); vrátiť nový HttpComponentsClientHttpRequestFactory (klient); }

10. Záver

V tomto článku sme prešli cez hlavné slovesá HTTP pomocou RestTemplate na organizáciu požiadaviek s využitím všetkých týchto možností.

Ak sa chcete zaoberať spôsobom overovania pomocou šablóny, prečítajte si náš článok o základnom overovaní pomocou RestTemplate.

Implementáciu všetkých týchto príkladov a útržkov kódu nájdete na GitHub.