streamalism.org

1. סקירה כללית

במדריך זה אנו נמחיש את מגוון הפעולות הרחב שבו לקוח האביב REST - RestTemplate - ניתן להשתמש בהם, ולהשתמש בהם היטב.

בצד ה- API של כל הדוגמאות, נפעיל מכאן את השירות RESTful.

2. הודעת פגיעה

החל מ- Spring Framework 5, לצד מחסנית WebFlux, הציגה Spring לקוח HTTP חדש בשם WebClient.

WebClient הוא לקוח HTTP מודרני וחלופי ל- RestTemplate. לא רק שהוא מספק ממשק API סינכרוני מסורתי, אלא שהוא תומך גם בגישה יעילה ללא חסימה ואסינכרונית.

עם זאת, אם אנו מפתחים יישומים חדשים או מעבירים יישומים ישנים, זה רעיון טוב להשתמש WebClient. להתקדם, RestTemplate יופסק בגרסאות עתידיות.

3. השתמש ב- GET כדי לאחזר משאבים

3.1. קבל JSON רגיל

נתחיל בפשטות ונדבר על בקשות GET, עם דוגמה מהירה באמצעות getForEntity () ממשק API:

RestTemplate restTemplate = RestTemplate חדש (); מחרוזת fooResourceUrl = "// localhost: 8080 / spring-rest / foos"; ResponseEntity response = restTemplate.getForEntity (fooResourceUrl + "/ 1", String.class); assertThat (response.getStatusCode (), equalTo (HttpStatus.OK));

שימו לב שיש לנו גישה מלאה לתגובת ה- HTTPכדי שנוכל לעשות דברים כמו לבדוק את קוד הסטטוס כדי לוודא שהפעולה הצליחה או לעבוד עם גוף התגובה בפועל:

ממפה ObjectMapper = ObjectMapper חדש (); שורש JsonNode = mapper.readTree (response.getBody ()); שם JsonNode = root.path ("שם"); assertThat (name.asText (), notNullValue ());

אנו עובדים עם גוף התגובה כמחרוזת סטנדרטית כאן ומשתמשים בג'קסון (ובמבנה הצומת של JSON שג'קסון מספק) כדי לאמת כמה פרטים.

3.2. אחזור POJO במקום JSON

אנו יכולים גם למפות את התגובה ישירות ל- DTO Resource:

מחלקה ציבורית Foo מיישמת לפי סדר {מזהה ארוך פרטי; שם מחרוזת פרטי; // סטרים וקובעים סטנדרטיים}

עכשיו אנחנו יכולים פשוט להשתמש ב- getForObject ממשק API בתבנית:

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

4. השתמש ב- HEAD כדי לאחזר כותרות

בואו נסתכל במהירות על השימוש ב- HEAD לפני שנמשיך לשיטות הנפוצות יותר.

אנו נשתמש ב- headForHeaders () ממשק API כאן:

HttpHeaders httpHeaders = restTemplate.headForHeaders (fooResourceUrl); assertTrue (httpHeaders.getContentType (). כולל (MediaType.APPLICATION_JSON));

5. השתמש ב- POST כדי ליצור משאב

על מנת ליצור משאב חדש ב- API, אנו יכולים לעשות שימוש טוב ב- postForLocation (), postForObject () אוֹ postForEntity () ממשקי API.

הראשון מחזיר את ה- URI של המשאב החדש שנוצר, ואילו השני מחזיר את המשאב עצמו.

5.1. ה postForObject () ממשק API

RestTemplate restTemplate = RestTemplate חדש (); HttpEntity בקשה = HttpEntity חדש (Foo חדש ("בר")); Foo foo = restTemplate.postForObject (fooResourceUrl, בקשה, Foo.class); assertThat (foo, notNullValue ()); assertThat (foo.getName (), הוא ("בר"));

5.2. ה postForLocation () ממשק API

באופן דומה, בואו נסתכל על הפעולה שבמקום להחזיר את המשאב המלא, פשוט מחזירה את מקום של המשאב החדש שנוצר:

HttpEntity בקשה = HttpEntity חדש (Foo חדש ("בר")); מיקום URI = restTemplate .postForLocation (fooResourceUrl, בקשה); assertThat (מיקום, notNullValue ());

5.3. ה לְהַחלִיף() ממשק API

בואו נסתכל כיצד לבצע פוסט עם כללי יותר לְהַחלִיף ממשק API:

RestTemplate restTemplate = RestTemplate חדש (); HttpEntity בקשה = HttpEntity חדש (Foo חדש ("בר")); תגובה ResponseEntity = restTemplate. Exchange (fooResourceUrl, HttpMethod.POST, בקשה, Foo.class); assertThat (response.getStatusCode (), הוא (HttpStatus.CREATED)); Foo foo = response.getBody (); assertThat (foo, notNullValue ()); assertThat (foo.getName (), הוא ("בר")); 

5.4. הגש נתוני טופס

לאחר מכן, בואו נבחן כיצד להגיש טופס בשיטת POST.

ראשית, עלינו להגדיר את סוג תוכן כותרת אל יישום / x-www-form-urlencoded.

זה מוודא שניתן לשלוח מחרוזת שאילתה גדולה לשרת, המכילה זוגות שם / ערך מופרדים על ידי &:

כותרות HttpHeaders = HttpHeaders חדשות (); headers.setContentType (MediaType.APPLICATION_FORM_URLENCODED);

אנו יכולים לעטוף את משתני הטופס לא LinkedMultiValueMap:

מפת MultiValueMap = חדש LinkedMultiValueMap (); map.add ("id", "1");

הַבָּא, אנו בונים את הבקשה באמצעות HttpEntity למשל:

HttpEntity בקשה = HttpEntity חדש (מפה, כותרות);

לבסוף, אנו יכולים להתחבר לשירות REST על ידי התקשרות restTemplate.postForEntity () בנקודת הקצה: /foos/טופס

ResponseEntity response = restTemplate.postForEntity (fooResourceUrl + "/ form", בקשה, String.class); assertThat (response.getStatusCode (), הוא (HttpStatus.CREATED));

6. השתמש באפשרויות כדי לקבל פעולות מותרות

לאחר מכן, נבחן במהירות שימוש בבקשת OPTIONS ובדיקת הפעולות המותרות ב- URI ספציפי באמצעות סוג זה של בקשה; ה- API הוא optionsForAllow:

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

7. השתמש ב- PUT כדי לעדכן משאב

לאחר מכן נתחיל לבחון את ה- PUT ובאופן ספציפי יותר את ה- לְהַחלִיף() ממשק API לפעולה זו מאז template.put API די פשוט.

7.1. פָּשׁוּט לָשִׂים עם לְהַחלִיף()

נתחיל בפעולת PUT פשוטה כנגד ה- API - ונזכור כי הפעולה אינה מחזירה גוף ללקוח:

Foo updatedInstance = new Foo ("newName"); updatedInstance.setId (createResponse.getBody (). getId ()); מחרוזת resourceUrl = fooResourceUrl + '/' + createResponse.getBody (). GetId (); HttpEntity requestUpdate = HttpEntity חדש (updatedInstance, כותרות); template.exchange (resourceUrl, HttpMethod.PUT, requestUpdate, Void.class);

7.2. לשים עם לְהַחלִיף() ובקשה להתקשרות חוזרת

בשלב הבא אנו נשתמש בהחזרת בקשה להחזרת PUT.

בואו נדאג שנכין את השיחה החוזרת, בה נוכל להגדיר את כל הכותרות הדרושות לנו וכן גוף בקשה:

RequestCallback requestCallback (סופי Foo updatedInstance) {return clientHttpRequest -> {ObjectMapper mapper = ObjectMapper new (); mapper.writeValue (clientHttpRequest.getBody (), updatedInstance); clientHttpRequest.getHeaders (). הוסף (HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE); clientHttpRequest.getHeaders (). הוסף (HttpHeaders.AUTHORIZATION, "Basic" + getBase64EncodedLogPass ()); }; }

לאחר מכן, אנו יוצרים את המשאב עם בקשת POST:

תגובה ResponseEntity = restTemplate. Exchange (fooResourceUrl, HttpMethod.POST, בקשה, Foo.class); assertThat (response.getStatusCode (), הוא (HttpStatus.CREATED));

ואז אנו מעדכנים את המשאב:

Foo updatedInstance = new Foo ("newName"); updatedInstance.setId (response.getBody (). getId ()); מחרוזת resourceUrl = fooResourceUrl + '/' + respons.getBody (). GetId (); restTemplate.execute (resourceUrl, HttpMethod.PUT, requestCallback (updatedInstance), clientHttpResponse -> null);

8. השתמש ב- DELETE כדי להסיר משאב

כדי להסיר משאב קיים, נשתמש במהירות ב- לִמְחוֹק() ממשק API:

מחרוזת entityUrl = fooResourceUrl + "/" + existingResource.getId (); restTemplate.delete (entityUrl); 

9. הגדר את פסק הזמן

אנחנו יכולים להגדיר RestTemplate לפסק זמן פשוט באמצעות ClientHttpRequestFactory:

RestTemplate restTemplate = RestTemplate חדש (getClientHttpRequestFactory ()); פרטי ClientHttpRequestFactory getClientHttpRequestFactory () {int-timeout = 5000; HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = HttpComponentsClientHttpRequestFactory חדש (); clientHttpRequestFactory.setConnectTimeout (פסק זמן); return clientHttpRequestFactory; }

ואנחנו יכולים להשתמש HttpClient לקבלת אפשרויות תצורה נוספות:

פרטי ClientHttpRequestFactory getClientHttpRequestFactory () {int-timeout = 5000; RequestConfig config = RequestConfig.custom () .setConnectTimeout (פסק זמן) .setConnectionRequestTimeout (פסק זמן) .setSocketTimeout (פסק זמן) .build (); CloseableHttpClient client = HttpClientBuilder .create () .setDefaultRequestConfig (config) .build (); להחזיר HttpComponentsClientHttpRequestFactory (לקוח) חדש; }

10. מסקנה

במאמר זה עברנו על פעלות ה- HTTP העיקריות באמצעות RestTemplate לתזמן בקשות באמצעות כל אלה.

אם ברצונך לחקור כיצד לבצע אימות באמצעות התבנית, עיין במאמר שלנו בנושא אימות בסיסי עם RestTemplate.

ניתן למצוא את היישום של כל הדוגמאות וקטעי הקוד ב- GitHub.