Ein Leitfaden für Unirest

1. Überblick

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

Beachten Sie, dass wir hiermocky.io für alle unsere HTTP-Anforderungen verwenden, bevor wir loslegen.

2. Maven Setup

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


    com.mashape.unirest
    unirest-java
    1.4.9

Schauen Sie sich die neueste Versionhere 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("http://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 flüssig, effizient und recht einfach zu lesen ist.

Wir übergeben Header und Parameter mit den APIsheader() undfields().

Die Anforderung wird beim Methodenaufruf vonasJson()aufgerufen. Wir haben hier auch andere Optionen, wieasBinary(), asString() undasObject().

Um mehrere Überschriften oder Felder zu übergeben, können Sie eine Karte erstellen und diese an.headers(Map<String, Object> headers) bzw..fields(Map<String, String> fields) ü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 example");
    fields.put("id", "PSP123");

    HttpResponse jsonResponse
      = Unirest.put("http://www.mocky.io/v2/5a9ce7853100002a00ab515e")
      .headers(headers).fields(fields)
      .asJson();

    assertNotNull(jsonResponse.getBody());
    assertEquals(202, jsonResponse.getStatus());
}

3.1. Abfrageparameter übergeben

Um Daten als AbfrageString, zu übergeben, verwenden wir die MethodequeryString():

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

3.2. Verwenden von Pfadparametern

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

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

Der Name des Parameterplatzhalters muss mit dem ersten Argument der Methode übereinstimmen.

3.3. Anfragen mit Körper

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

@Test
public void givenRequestBodyWhenCreatedThenCorrect() {

    HttpResponse jsonResponse
      = Unirest.post("http://www.mocky.io/v2/5a9ce7663100006800ab515d")
      .body("{\"name\":\"Sam example\", \"city\":\"viena\"}")
      .asJson();

    assertEquals(201, jsonResponse.getStatus());
}

3.4. Object Mapper

Um dieasObject() oderbody() in der Anfrage zu verwenden, müssen wir unseren Objekt-Mapper definieren. Der Einfachheit halber verwenden wir den Jackson-Objekt-Mapper.

Fügen wir zunächstpom.xml die folgenden Abhängigkeiten hinzu:


    com.fasterxml.jackson.core
    jackson-databind
    2.9.4

Verwenden Sie immer die neueste Version überon 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, dasssetObjectMapper() nur einmal aufgerufen werden sollte, um den Mapper festzulegen. Sobald die Mapper-Instanz festgelegt ist, wird sie für alle Anfragen und Antworten verwendet.

Testen wir nun die neue Funktionalität mit einem benutzerdefiniertenArticle-Objekt:

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

    assertEquals(201, jsonResponse.getStatus());
}

4. Anforderungsmethoden

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

POST:

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

PUT:

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

GET:

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

LÖSCHEN:

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

PATCH:

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

OPTIONEN:

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

5. Antwortmethoden

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

//...
jsonResponse.getStatus()

//...

Extrahieren Sie die Überschriften:

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

Den Antworttext abrufen:

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

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

6. Asynchrone Anforderungen bearbeiten

Unirest kann auch asynchrone Anforderungen verarbeiten - mitjava.util.concurrent.Future und Rückrufmethoden:

@Test
public void whenAysncRequestShouldReturnOk() {
    Future> future = Unirest.post(
      "http://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());
}

Diecom.mashape.unirest.http.async.Callback<T>-Schnittstelle bietet drei Methoden:failed(),cancelled() undcompleted().

Überschreiben Sie die Methoden, um die erforderlichen Vorgänge abhängig von der Antwort auszuführen.

7. Datei-Uploads

Übergeben Sie zum Hochladen oder Senden einer Datei als Teil der Anforderung das Objektjava.io.Fileals Feld mit der Namensdatei:

@Test
public void givenFileWhenUploadedThenCorrect() {

    HttpResponse jsonResponse = Unirest.post(
      "http://www.mocky.io/v2/5a9ce7663100006800ab515d")
      .field("file", new File("/path/to/file"))
      .asJson();

    assertEquals(201, jsonResponse.getStatus());
}

Wir können auchByteStream: verwenden

@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(
          "http://www.mocky.io/v2/5a9ce7663100006800ab515d")
          .field("file", bytes, "article.txt")
          .asJson();

        assertEquals(201, jsonResponse.getStatus());
    }
}

Oder verwenden Sie den Eingabestream direkt und fügen SieContentType.APPLICATION_OCTET_STREAM als zweites Argument in die Methodefields() ein:

@Test
public void givenInputStreamWhenUploadedThenCorrect() {
    try (InputStream inputStream = new FileInputStream(
      new File("/path/to/file/artcile.txt"))) {

        HttpResponse jsonResponse = Unirest.post(
          "http://www.mocky.io/v2/5a9ce7663100006800ab515d")
          .field("file", inputStream, ContentType.APPLICATION_OCTET_STREAM, "article.txt").asJson();

        assertEquals(201, jsonResponse.getStatus());
    }
}

8. Unirest Konfigurationen

Das Framework unterstützt auch typische Konfigurationen eines HTTP-Clients wie Verbindungspooling, Timeouts, globale Header usw.

Legen Sie die Anzahl der Verbindungen und die Anzahl der maximalen Verbindungen pro Route fest:

Unirest.setConcurrency(20, 5);

Verbindungs-und Socket-Timeouts konfigurieren:

Unirest.setTimeouts(20000, 15000);

Beachten Sie, dass die Zeitwerte in Millisekunden angegeben sind.

Jetzt legen wir HTTP-Header für alle unsere Anforderungen fest:

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

Wir können die globalen Header jederzeit löschen:

Unirest.clearDefaultHeaders();

Irgendwann müssen wir möglicherweise Anforderungen über einen Proxyserver stellen:

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

Ein wichtiger Aspekt, der beachtet werden muss, ist das ordnungsgemäße Schließen oder Beenden der Anwendung. Unirest erzeugt eine Hintergrundereignisschleife, um die Vorgänge zu verarbeiten. Wir müssen diese Schleife schließen, bevor wir unsere Anwendung beenden:

Unirest.shutdown();

9. Fazit

In diesem Tutorial haben wir uns auf das schlanke HTTP-Client-Framework Unirest konzentriert. Wir haben mit einigen einfachen Beispielen gearbeitet, sowohl im synchronen als auch im asynchronen Modus.

Schließlich haben wir auch mehrere erweiterte Konfigurationen verwendet - wie z. B. Verbindungspooling, Proxy-Einstellungen usw.

Wie üblich ist der Quellcodeover on GitHub verfügbar.

TOC

Ein Leitfaden für Unirest