Buchung mit HttpClient

Posten mit HttpClient

1. Überblick

In diesem Tutorial -we’ll POST with the HttpClient 4 - wird zuerst die Autorisierung und dann die fließende HttpClient-API verwendet.

Abschließend wird erläutert, wie Sie eine Datei mit Httpclient hochladen.

Weitere Lektüre:

Erweiterte HttpClient-Konfiguration

HTTP-Client-Konfigurationen für erweiterte Anwendungsfälle.

HttpClient 4 - Benutzerdefiniertes Cookie senden

So senden Sie benutzerdefinierte Cookies mit dem Apache HttpClient 4.

HTTP-Client mit SSL

Beispiel für die Konfiguration des HTTP-Clients mit SSL.

2. Grundlegender POST

Lassen Sie uns zunächst ein einfaches Beispiel durchgehen und eine POST-Anfrage mitHttpClient senden.

Wir werden einen POST mit zwei Parametern durchführen - "username" und "password":

@Test
public void whenSendPostRequestUsingHttpClient_thenCorrect()
  throws ClientProtocolException, IOException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost("http://www.example.com");

    List params = new ArrayList();
    params.add(new BasicNameValuePair("username", "John"));
    params.add(new BasicNameValuePair("password", "pass"));
    httpPost.setEntity(new UrlEncodedFormEntity(params));

    CloseableHttpResponse response = client.execute(httpPost);
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    client.close();
}

Beachten Sie, wie wirList vonNameValuePair verwendet haben, um Parameter in die POST-Anforderung aufzunehmen.

3. POST mit Autorisierung

Als Nächstes sehen wir uns an, wie Sie einen POST mit Authentifizierungsdaten mithilfe vonHttpClientdurchführen.

Im folgenden Beispiel senden wir eine POST-Anforderung an eine mit der Standardauthentifizierung gesicherte URL, indem wir einen Autorisierungsheader hinzufügen:

@Test
public void whenSendPostRequestWithAuthorizationUsingHttpClient_thenCorrect()
  throws ClientProtocolException, IOException, AuthenticationException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost("http://www.example.com");

    httpPost.setEntity(new StringEntity("test post"));
    UsernamePasswordCredentials creds
      = new UsernamePasswordCredentials("John", "pass");
    httpPost.addHeader(new BasicScheme().authenticate(creds, httpPost, null));

    CloseableHttpResponse response = client.execute(httpPost);
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    client.close();
}

4. POST mit JSON

Nun sehen wir uns an, wie Sie eine POST-Anforderung mit einem JSON-Body unter Verwendung vonHttpClient senden.

Im folgenden Beispiel senden wir einigeperson-Informationen (id, name) als JSON:

@Test
public void whenPostJsonUsingHttpClient_thenCorrect()
  throws ClientProtocolException, IOException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost("http://www.example.com");

    String json = "{"id":1,"name":"John"}";
    StringEntity entity = new StringEntity(json);
    httpPost.setEntity(entity);
    httpPost.setHeader("Accept", "application/json");
    httpPost.setHeader("Content-type", "application/json");

    CloseableHttpResponse response = client.execute(httpPost);
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    client.close();
}

Beachten Sie, wie wirStringEntity verwenden, um den Hauptteil der Anforderung festzulegen.

We’re also setting the ContentType header to application/json, um dem Server die erforderlichen Informationen zur Darstellung des von uns gesendeten Inhalts zu geben.

5. POST mitHttpClient Fluent API

Als nächstes POSTEN wir mit derHttpClient Fluent API.

Wir senden eine Anfrage mit zwei Parametern "username" und "password":

@Test
public void whenPostFormUsingHttpClientFluentAPI_thenCorrect()
  throws ClientProtocolException, IOException {
    HttpResponse response = Request.Post("http://www.example.com").bodyForm(
      Form.form().add("username", "John").add("password", "pass").build())
      .execute().returnResponse();

    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
}

6. POST Multipart Request

Lassen Sie uns nun eine mehrteilige Anfrage stellen.

Wir veröffentlichen einFile, einen Benutzernamen und ein Passwort mitMultipartEntityBuilder:

@Test
public void whenSendMultipartRequestUsingHttpClient_thenCorrect()
  throws ClientProtocolException, IOException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost("http://www.example.com");

    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    builder.addTextBody("username", "John");
    builder.addTextBody("password", "pass");
    builder.addBinaryBody(
      "file", new File("test.txt"), ContentType.APPLICATION_OCTET_STREAM, "file.ext");

    HttpEntity multipart = builder.build();
    httpPost.setEntity(multipart);

    CloseableHttpResponse response = client.execute(httpPost);
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    client.close();
}

7. Laden Sie aFile mitHttpClient hoch

Als nächstes sehen wir uns an, wie SieFile mitHttpClient. hochladen

Wir laden die Datei "test.txt" mitMultipartEntityBuilder hoch:

@Test
public void whenUploadFileUsingHttpClient_thenCorrect()
  throws ClientProtocolException, IOException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost("http://www.example.com");

    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    builder.addBinaryBody(
      "file", new File("test.txt"), ContentType.APPLICATION_OCTET_STREAM, "file.ext");
    HttpEntity multipart = builder.build();
    httpPost.setEntity(multipart);

    CloseableHttpResponse response = client.execute(httpPost);
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    client.close();
}

8. Holen Sie sichFile Upload Fortschritt

Zum Schluss sehen wir uns an, wie Sie den Fortschritt des Uploads vonFilemitHttpClient ermitteln.

Im folgenden Beispiel erweitern wir dieHttpEntityWrapper, um einen Einblick in den Upload-Prozess zu erhalten.

Erstens - hier ist die Upload-Methode:

@Test
public void whenGetUploadFileProgressUsingHttpClient_thenCorrect()
  throws ClientProtocolException, IOException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost("http://www.example.com");

    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    builder.addBinaryBody(
      "file", new File("test.txt"), ContentType.APPLICATION_OCTET_STREAM, "file.ext");
    HttpEntity multipart = builder.build();

    ProgressEntityWrapper.ProgressListener pListener =
      percentage -> assertFalse(Float.compare(percentage, 100) > 0);
    httpPost.setEntity(new ProgressEntityWrapper(multipart, pListener));

    CloseableHttpResponse response = client.execute(httpPost);
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    client.close();
}

Wir werden auch die SchnittstelleProgressListener hinzufügen, mit der wir den Upload-Fortschritt beobachten können:

public static interface ProgressListener {
    void progress(float percentage);
}

Und hier ist unsere erweiterte Version vonHttpEntityWrapper "ProgressEntityWrapper":

public class ProgressEntityWrapper extends HttpEntityWrapper {
    private ProgressListener listener;

    public ProgressEntityWrapper(HttpEntity entity, ProgressListener listener) {
        super(entity);
        this.listener = listener;
    }

    @Override
    public void writeTo(OutputStream outstream) throws IOException {
        super.writeTo(new CountingOutputStream(outstream, listener, getContentLength()));
    }
}

Und die erweiterte Version vonFilterOutputStream „CountingOutputStream“:

public static class CountingOutputStream extends FilterOutputStream {
    private ProgressListener listener;
    private long transferred;
    private long totalBytes;

    public CountingOutputStream(
      OutputStream out, ProgressListener listener, long totalBytes) {
        super(out);
        this.listener = listener;
        transferred = 0;
        this.totalBytes = totalBytes;
    }

    @Override
    public void write(byte[] b, int off, int len) throws IOException {
        out.write(b, off, len);
        transferred += len;
        listener.progress(getCurrentProgress());
    }

    @Override
    public void write(int b) throws IOException {
        out.write(b);
        transferred++;
        listener.progress(getCurrentProgress());
    }

    private float getCurrentProgress() {
        return ((float) transferred / totalBytes) * 100;
    }
}

Beachten Sie, dass:

Wenn SieFilterOutputStream auf „CountingOutputStream” – erweitern, überschreiben wir die Methodewrite(), um die geschriebenen (übertragenen) Bytes zu zählen
Wenn SieHttpEntityWrapper auf „ProgressEntityWrapper” – erweitern, überschreiben wir die MethodewriteTo(), um unsere“CountingOutputStream” zu verwenden

9. Fazit

In diesem Tutorial haben wir die häufigsten Methoden zum Senden von POST-HTTP-Anforderungen mitApache HttpClient 4 veranschaulicht.

Wir haben gelernt, wie man eine POST-Anfrage mit Autorisierung sendet, wie man mit der fließenden API vonHttpClientpostet und wie man eine Datei hochlädt und ihren Fortschritt verfolgt.

Die Implementierung all dieser Beispiele und Codefragmente finden Sie inthe github project.

TOC