Posting mit HttpClient

1. Übersicht

In diesem Tutorial - wir werden mit dem HttpClient 4 POSTEN - verwenden Sie zuerst die Autorisierung und dann die fließende HttpClient-API.

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

2. Grundlegender POST

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

Wir werden einen POST mit zwei Parametern durchführen - " Benutzername " und " Passwort ":

@Test public void whenSendPostRequestUsingHttpClient_thenCorrect() throws ClientProtocolException, IOException { CloseableHttpClient client = HttpClients.createDefault(); HttpPost httpPost = new HttpPost("//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 wir eine Liste von NameValuePair verwendet haben , um Parameter in die POST-Anforderung aufzunehmen.

3. POST Mit Autorisierung

Als Nächstes sehen wir uns an, wie ein POST mit Authentifizierungsdaten mithilfe des HttpClient ausgeführt wird .

Im folgenden Beispiel senden wir eine POST-Anforderung an eine mit 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("//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 eine POST-Anforderung mit einem JSON-Body mithilfe des HttpClient gesendet wird .

Im folgenden Beispiel senden wir einige Personeninformationen ( ID, Name ) als JSON:

@Test public void whenPostJsonUsingHttpClient_thenCorrect() throws ClientProtocolException, IOException { CloseableHttpClient client = HttpClients.createDefault(); HttpPost httpPost = new HttpPost("//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 wir die StringEntity verwenden , um den Hauptteil der Anforderung festzulegen .

Außerdem setzen wir den ContentType- Header auf application / json , um dem Server die erforderlichen Informationen zur Darstellung des von uns gesendeten Inhalts zu geben.

5. POST Mit der HttpClient Fluent API

Als nächstes POSTEN wir mit der HttpClient Fluent API.

Wir werden eine Anfrage mit zwei Parametern " Benutzername " und " Passwort " senden :

@Test public void whenPostFormUsingHttpClientFluentAPI_thenCorrect() throws ClientProtocolException, IOException { HttpResponse response = Request.Post("//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 werden eine Datei , einen Benutzernamen und ein Passwort mit MultipartEntityBuilder veröffentlichen :

@Test public void whenSendMultipartRequestUsingHttpClient_thenCorrect() throws ClientProtocolException, IOException { CloseableHttpClient client = HttpClients.createDefault(); HttpPost httpPost = new HttpPost("//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 eine Datei mit HttpClient hoch

Als nächstes sehen wir uns an, wie Sie eine Datei mit dem HttpClient hochladen .

Wir werden die Datei " test.txt " mit MultipartEntityBuilder hochladen :

@Test public void whenUploadFileUsingHttpClient_thenCorrect() throws ClientProtocolException, IOException { CloseableHttpClient client = HttpClients.createDefault(); HttpPost httpPost = new HttpPost("//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 Datei hochladen Fortschritt

Zum Schluss sehen wir uns an, wie Sie den Fortschritt des Datei- Uploads mit HttpClient ermitteln können .

Im folgenden Beispiel erweitern wir den HttpEntityWrapper , um 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("//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 Schnittstelle ProgressListener 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 von HttpEntityWrapperProgressEntityWrapper “:

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 von FilterOutputStreamCountingOutputStream “:

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 Sie FilterOutputStream auf " CountingOutputStream" erweitern, überschreiben wir die write () -Methode, um die geschriebenen (übertragenen) Bytes zu zählen
  • Wenn Sie HttpEntityWrapper auf " ProgressEntityWrapper" erweitern, überschreiben wir die writeTo () -Methode, um unseren "CountingOutputStream" zu verwenden.

9. Fazit

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

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

Die Implementierung all dieser Beispiele und Codefragmente finden Sie im Github-Projekt.