Ein Leitfaden für Unirest

1. Übersicht

Unirest ist eine leichtgewichtige HTTP-Client-Bibliothek von Mashape. Neben Java ist es auch für Node.js, .Net, Python, Ruby usw. verfügbar.

Bevor wir loslegen, beachten Sie, dass wir hier mocky.io für alle unsere HTTP-Anfragen verwenden.

2. Maven Setup

Fügen Sie zunächst die erforderlichen Abhängigkeiten hinzu:

 com.mashape.unirest unirest-java 1.4.9 

Schauen Sie sich hier die neueste Version an.

3. Einfache Anfragen

Senden wir eine einfache HTTP-Anfrage, um die Semantik des Frameworks zu verstehen:

@Test public void shouldReturnStatusOkay() { HttpResponse jsonResponse = Unirest.get("//www.mocky.io/v2/5a9ce37b3100004f00ab5154") .header("accept", "application/json").queryString("apiKey", "123") .asJson(); assertNotNull(jsonResponse.getBody()); assertEquals(200, jsonResponse.getStatus()); }

Beachten Sie, dass die API fließend, effizient und leicht zu lesen ist.

Wir übergeben Header und Parameter mit den APIs header () und fields () .

Die Anforderung wird beim Methodenaufruf asJson () aufgerufen. Wir haben hier auch andere Optionen, wie z. B. asBinary (), asString () und asObject ().

Um mehrere Überschriften oder Felder zu übergeben, können Sie eine Karte erstellen und diese an .headers (Kartenüberschriften) bzw. .fields (Kartenfelder) übergeben :

@Test public void shouldReturnStatusAccepted() { Map headers = new HashMap(); headers.put("accept", "application/json"); headers.put("Authorization", "Bearer 5a9ce37b3100004f00ab5154"); Map fields = new HashMap(); fields.put("name", "Sam Baeldung"); fields.put("id", "PSP123"); HttpResponse jsonResponse = Unirest.put("//www.mocky.io/v2/5a9ce7853100002a00ab515e") .headers(headers).fields(fields) .asJson(); assertNotNull(jsonResponse.getBody()); assertEquals(202, jsonResponse.getStatus()); }

3.1. Abfrageparameter übergeben

Um Daten als Abfragezeichenfolge zu übergeben , verwenden wir die queryString () -Methode:

HttpResponse jsonResponse = Unirest.get("//www.mocky.io/v2/5a9ce37b3100004f00ab5154") .queryString("apiKey", "123")

3.2. Verwenden von Pfadparametern

Zum Übergeben von URL-Parametern können wir die routeParam () -Methode verwenden:

HttpResponse jsonResponse = Unirest.get("//www.mocky.io/v2/5a9ce37b3100004f00ab5154/{userId}") .routeParam("userId", "123")

Der Name des Parameterplatzhalters muss mit dem ersten Argument für die Methode identisch sein.

3.3. Anfragen mit Körper

Wenn für unsere Anforderung ein String / JSON-Body erforderlich ist, übergeben wir ihn mit der body () -Methode:

@Test public void givenRequestBodyWhenCreatedThenCorrect() { HttpResponse jsonResponse = Unirest.post("//www.mocky.io/v2/5a9ce7663100006800ab515d") .body("{\"name\":\"Sam Baeldung\", \"city\":\"viena\"}") .asJson(); assertEquals(201, jsonResponse.getStatus()); }

3.4. Object Mapper

Um das asObject () oder body () in der Anfrage zu verwenden, müssen wir unseren Objekt-Mapper definieren. Der Einfachheit halber verwenden wir den Jackson Object Mapper.

Fügen wir zunächst die folgenden Abhängigkeiten zu pom.xml hinzu :

 com.fasterxml.jackson.core jackson-databind 2.9.4 

Verwenden Sie immer die neueste Version von Maven Central.

Jetzt konfigurieren wir unseren Mapper:

Unirest.setObjectMapper(new ObjectMapper() { com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper(); public String writeValue(Object value) { return mapper.writeValueAsString(value); } public  T readValue(String value, Class valueType) { return mapper.readValue(value, valueType); } });

Beachten Sie, dass setObjectMapper () nur einmal aufgerufen werden sollte, um den Mapper festzulegen . Sobald die Mapper-Instanz festgelegt ist, wird sie für alle Anfragen und Antworten verwendet.

Lassen Sie uns nun die neue Funktionalität mit einem benutzerdefinierten Artikelobjekt testen :

@Test public void givenArticleWhenCreatedThenCorrect() { Article article = new Article("ID1213", "Guide to Rest", "baeldung"); HttpResponse jsonResponse = Unirest.post("//www.mocky.io/v2/5a9ce7663100006800ab515d") .body(article) .asJson(); assertEquals(201, jsonResponse.getStatus()); }

4. Methoden anfordern

Ähnlich wie bei jedem HTTP-Client bietet das Framework separate Methoden für jedes HTTP-Verb:

POST:

Unirest.post("//www.mocky.io/v2/5a9ce7663100006800ab515d")

STELLEN:

Unirest.put("//www.mocky.io/v2/5a9ce7663100006800ab515d")

BEKOMMEN:

Unirest.get("//www.mocky.io/v2/5a9ce7663100006800ab515d")

LÖSCHEN:

Unirest.delete("//www.mocky.io/v2/5a9ce7663100006800ab515d")

PATCH:

Unirest.patch("//www.mocky.io/v2/5a9ce7663100006800ab515d")

OPTIONEN:

Unirest.options("//www.mocky.io/v2/5a9ce7663100006800ab515d")

5. Antwortmethoden

Sobald wir die Antwort erhalten haben, überprüfen wir den Statuscode und die Statusmeldung:

//... jsonResponse.getStatus() //...

Extrahieren Sie die Header:

//... jsonResponse.getHeaders(); //...

Holen Sie sich den Antworttext:

//... jsonResponse.getBody(); jsonResponse.getRawBody(); //...

Beachten Sie, dass getRawBody () einen Stream des nicht analysierten Antwortkörpers zurückgibt, während getBody () den analysierten Körper unter Verwendung des im vorherigen Abschnitt definierten Objekt- Mappers zurückgibt.

6. Behandlung von asynchronen Anforderungen

Unirest kann auch asynchrone Anforderungen verarbeiten - mithilfe der Methoden java.util.concurrent.Future und callback:

@Test public void whenAysncRequestShouldReturnOk() { Future
    
      future = Unirest.post( "//www.mocky.io/v2/5a9ce37b3100004f00ab5154?mocky-delay=10000ms") .header("accept", "application/json") .asJsonAsync(new Callback() { public void failed(UnirestException e) { // Do something if the request failed } public void completed(HttpResponse response) { // Do something if the request is successful } public void cancelled() { // Do something if the request is cancelled } }); assertEquals(200, future.get().getStatus()); }
    

The com.mashape.unirest.http.async.Callback interface provides three methods, failed(), cancelled() and completed().

Override the methods to perform the necessary operations depending on the response.

7. File Uploads

To upload or send a file as a part of the request, pass a java.io.File object as a field with name file:

@Test public void givenFileWhenUploadedThenCorrect() { HttpResponse jsonResponse = Unirest.post( "//www.mocky.io/v2/5a9ce7663100006800ab515d") .field("file", new File("/path/to/file")) .asJson(); assertEquals(201, jsonResponse.getStatus()); }

We can also use ByteStream:

@Test public void givenByteStreamWhenUploadedThenCorrect() { try (InputStream inputStream = new FileInputStream( new File("/path/to/file/artcile.txt"))) { byte[] bytes = new byte[inputStream.available()]; inputStream.read(bytes); HttpResponse jsonResponse = Unirest.post( "//www.mocky.io/v2/5a9ce7663100006800ab515d") .field("file", bytes, "article.txt") .asJson(); assertEquals(201, jsonResponse.getStatus()); } }

Or use the input stream directly, adding the ContentType.APPLICATION_OCTET_STREAM as the second argument in the fields() method:

@Test public void givenInputStreamWhenUploadedThenCorrect() { try (InputStream inputStream = new FileInputStream( new File("/path/to/file/artcile.txt"))) { HttpResponse jsonResponse = Unirest.post( "//www.mocky.io/v2/5a9ce7663100006800ab515d") .field("file", inputStream, ContentType.APPLICATION_OCTET_STREAM, "article.txt").asJson(); assertEquals(201, jsonResponse.getStatus()); } }

8. Unirest Configurations

The framework also supports typical configurations of an HTTP client like connection pooling, timeouts, global headers etc.

Let's set the number of connections and number maximum connections per route:

Unirest.setConcurrency(20, 5);

Configure connection and socket timeouts :

Unirest.setTimeouts(20000, 15000);

Note that the time values are in milliseconds.

Now let's set HTTP headers for all our requests:

Unirest.setDefaultHeader("X-app-name", "baeldung-unirest"); Unirest.setDefaultHeader("X-request-id", "100004f00ab5");

We can clear the global headers anytime:

Unirest.clearDefaultHeaders();

At some point, we might need to make requests through a proxy server:

Unirest.setProxy(new HttpHost("localhost", 8080));

One important aspect to be aware of is closing or exiting the application gracefully. Unirest spawns a background event loop to handle the operations, we need to shut down that loop before exiting our application:

Unirest.shutdown();

9. Conclusion

In this tutorial, we focused on the lightweight HTTP client framework – Unirest. We worked with some simple examples, both in a synchronous but also async modes.

Finally, we also used several advanced configurations – such as connection pooling, proxy settings etc.

Wie üblich ist der Quellcode über GitHub verfügbar.