streamalism.org

1. Áttekintés

Ebben az oktatóanyagban a műveletek széles körét mutatjuk be, ahol a Spring REST Client - RestTemplate - használható, és jól használható.

Az összes példa API oldalán itt fogjuk futtatni a RESTful szolgáltatást.

2. Az elévülésről szóló értesítés

A Spring Framework 5-től kezdve a WebFlux-verem mellett a Spring bemutatott egy új HTTP-klienst Web Ügyfél.

Web Ügyfél egy modern, alternatív HTTP kliens a RestTemplate. Nemcsak hagyományos szinkron API-t biztosít, hanem hatékony, blokkolás nélküli és aszinkron megközelítést is.

Ez azt jelenti, hogy ha új alkalmazásokat fejlesztünk vagy egy régit telepítünk át, jó ötlet használni Web Ügyfél. Haladni előre, RestTemplate a következő verziókban megszűnik.

3. Használja a GET-et az erőforrások lekéréséhez

3.1. Get Plain JSON

Kezdjük egyszerûen, és beszéljünk a GET-kérésekrõl egy gyors példa a getForEntity () API:

RestTemplate restTemplate = új RestTemplate (); String fooResourceUrl = "// localhost: 8080 / spring-rest / foos"; ResponseEntity response = restTemplate.getForEntity (fooResourceUrl + "/ 1", String.class); assertThat (válasz.getStatusCode (), egyenlőTo (HttpStatus.OK));

Figyelje meg, hogy teljes hozzáféréssel rendelkezünk a HTTP válaszhoz, így megtehetjük például az állapotkód ellenőrzését, hogy megbizonyosodjunk arról, hogy a művelet sikeres volt-e, vagy működhetünk a válasz tényleges törzsével:

ObjectMapper mapper = új ObjectMapper (); JsonNode gyökér = mapper.readTree (response.getBody ()); JsonNode név = root.path ("név"); assertThat (név.asText (), notNullValue ());

Itt a választesttel szokásos karakterláncként dolgozunk, és Jackson (és a JSON csomópontstruktúra, amelyet Jackson nyújt) segítségével ellenőrizzük néhány részletet.

3.2. POJO lekérése JSON helyett

A választ közvetlenül is leképezhetjük egy erőforrás DTO-ra:

a Foo nyilvános osztály Serializable {private long id; privát karakterlánc neve; // szabványos mérőeszközök és beállítók}

Most egyszerűen használhatjuk a getForObject API a sablonban:

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

4. Használja a HEAD elemet a fejlécek lekéréséhez

Most nézzük meg gyorsan a HEAD alkalmazását, mielőtt továbblépnénk a gyakoribb módszerekre.

Használni fogjuk a headForHeaders () API itt:

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

5. A POST segítségével hozzon létre egy erőforrást

Új erőforrás létrehozása érdekében az API-ban jól ki tudjuk használni a postForLocation (), postForObject () vagy postForEntity () API-k.

Az első az újonnan létrehozott erőforrás URI-ját adja vissza, míg a második magát az erőforrást adja vissza.

5.1. A postForObject () API

RestTemplate restTemplate = új RestTemplate (); HttpEntity request = new HttpEntity (new Foo ("bar")); Foo foo = restTemplate.postForObject (fooResourceUrl, request, Foo.class); assertThat (foo, notNullValue ()); assertThat (foo.getName (), is ("sáv"));

5.2. A postForLocation () API

Hasonlóképpen nézzük meg azt a műveletet, amely a teljes erőforrás visszaadása helyett csak a Elhelyezkedés az újonnan létrehozott erőforrás:

HttpEntity request = new HttpEntity (new Foo ("bar")); URI hely = restTemplate .postForLocation (fooResourceUrl, kérés); assertThat (hely, nemNullValue ());

5.3. A csere() API

Nézzük meg, hogyan lehet POST-ot csinálni az általánosabbal csere API:

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

5.4. Űrlapadatok benyújtása

Ezután nézzük meg, hogyan lehet űrlapot beküldeni a POST módszer segítségével.

Először be kell állítanunk a Tartalom típus fejléc application / x-www-form-urlencoded.

Ez biztosítja, hogy egy nagyméretű lekérdezési karakterláncot el lehet küldeni a kiszolgálónak, névvel és értékpárral elválasztva &:

HttpHeaders fejlécek = new HttpHeaders (); header.setContentType (MediaType.APPLICATION_FORM_URLENCODED);

A formaváltozókat a-ba csomagolhatjuk LinkedMultiValueMap:

MultiValueMap map = new LinkedMultiValueMap (); map.add ("id", "1");

Következő, a Request-et egy HttpEntity példa:

HttpEntity kérelem = új HttpEntity (térkép, fejlécek);

Végül hívással csatlakozhatunk a REST szolgáltatáshoz restTemplate.postForEntity () a végponton: /foos/forma

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

6. Használja az OPTIONS lehetőséget az engedélyezett műveletek megszerzéséhez

Ezután gyorsan megnézzük az OPTIONS kérés használatát, és egy ilyen URI használatával feltárjuk egy adott URI engedélyezett műveleteit; az API az optionsForAllow:

Set optionsForAllow = restTemplate.optionsForAllow (fooResourceUrl); HttpMethod [] támogatottMethods = {HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE}; assertTrue (optionsForAllow.containsAll (tömbök.asList (támogatottMetódok)));

7. A PUT segítségével frissítse az erőforrást

Ezután elkezdjük vizsgálni a PUT-ot és pontosabban a csere() API ehhez a művelethez, mivel a template.put Az API meglehetősen egyszerű.

7.1. Egyszerű PUT Val vel csere()

Egy egyszerű PUT művelettel kezdjük az API-t - és ne feledje, hogy a művelet nem ad vissza egy törzset az ügyfélnek:

Foo updatedInstance = new Foo ("újNév"); updatedInstance.setId (createResponse.getBody (). getId ()); String resourceUrl = fooResourceUrl + '/' + createResponse.getBody (). GetId (); HttpEntity requestUpdate = új HttpEntity (updatedInstance, fejlécek); template.exchange (resourceUrl, HttpMethod.PUT, requestUpdate, Void.class);

7.2. PUT With csere() és egy Visszahívás kérése

Ezután egy visszahívási kérelmet fogunk használni egy PUT kiadásához.

Ügyeljünk arra, hogy előkészítsük a visszahívást, ahol beállíthatjuk az összes szükséges fejlécet, valamint egy kéréstestet:

RequestCallback requestCallback (végső Foo updatedInstance) {return clientHttpRequest -> {ObjectMapper mapper = új ObjectMapper (); mapper.writeValue (clientHttpRequest.getBody (), updatedInstance); clientHttpRequest.getHeaders (). add (HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE); clientHttpRequest.getHeaders (). add (HttpHeaders.AUTHORIZATION, "Basic" + getBase64EncodedLogPass ()); }; }

Ezután létrehozzuk az erőforrást POST kéréssel:

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

Ezután frissítjük az erőforrást:

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

8. Az erőforrás eltávolításához használja a DELETE billentyűt

Meglévő erőforrás eltávolításához gyorsan felhasználjuk a töröl() API:

Karakterlánc entitásUrl = fooResourceUrl + "/" + existingResource.getId (); restTemplate.delete (entitásUrl); 

9. Konfigurálja az Időkorlátot

Konfigurálhatjuk RestTemplate hogy egyszerűen használjuk az időt ClientHttpRequestFactory:

RestTemplate restTemplate = new RestTemplate (getClientHttpRequestFactory ()); privát ClientHttpRequestFactory getClientHttpRequestFactory () {int timeout = 5000; HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory (); clientHttpRequestFactory.setConnectTimeout (timeout); return clientHttpRequestFactory; }

És használhatjuk HttpClient további konfigurációs lehetőségekért:

privát ClientHttpRequestFactory getClientHttpRequestFactory () {int timeout = 5000; RequestConfig config = RequestConfig.custom () .setConnectTimeout (timeout) .setConnectionRequestTimeout (timeout) .setSocketTimeout (timeout) .build (); CloseableHttpClient kliens = HttpClientBuilder .create () .setDefaultRequestConfig (config) .build (); return new HttpComponentsClientHttpRequestFactory (kliens); }

10. Következtetés

Ebben a cikkben áttekintettük a fő HTTP igék használatát RestTemplate hogy a kéréseket mindezek felhasználásával hangszerelje.

Ha meg akarja találni a sablonnal történő hitelesítés módját, olvassa el az Alapvető hitelesítés a RestTemplate szolgáltatással című cikkünket.

Ezen példák és kódrészletek megvalósítása megtalálható a GitHub-on.