Publication avec HttpClient

1. Vue d'ensemble

Dans ce tutoriel - nous allons POST avec HttpClient 4 - en utilisant la première autorisation, puis l'API HttpClient fluide.

Enfin, nous verrons comment télécharger un fichier à l'aide de Httpclient.

2. POST de base

Tout d'abord, passons en revue un exemple simple et envoyons une requête POST à ​​l'aide de HttpClient .

Nous allons faire un POST avec deux paramètres - « nom d'utilisateur » et « mot de passe »:

@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(); }

Notez comment nous avons utilisé une liste de NameValuePair pour inclure des paramètres dans la requête POST.

3. POST avec autorisation

Ensuite, voyons comment effectuer un POST avec des informations d'identification d'authentification à l'aide de HttpClient .

Dans l'exemple suivant, nous envoyons une requête POST à ​​une URL sécurisée avec l'authentification de base en ajoutant un en-tête d'autorisation:

@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 avec JSON

Voyons maintenant comment envoyer une requête POST avec un corps JSON à l'aide de HttpClient .

Dans l'exemple suivant, nous envoyons des informations sur la personne ( identifiant, nom ) au format 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(); }

Notez comment nous utilisons StringEntity pour définir le corps de la requête.

Nous définissons également l'en- tête ContentType sur application / json pour donner au serveur les informations nécessaires sur la représentation du contenu que nous envoyons.

5. POST avec l' API HttpClient Fluent

Ensuite, POSTONS avec l' API HttpClient Fluent.

Nous allons envoyer une requête avec deux paramètres « nom d'utilisateur » et « mot de passe »:

@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 Demande en plusieurs parties

Maintenant, POSTONS une requête en plusieurs parties.

Nous publierons un fichier , un nom d'utilisateur et un mot de passe à l'aide de MultipartEntityBuilder :

@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. Télécharger un fichier à l' aide de HttpClient

Ensuite, voyons comment télécharger un fichier à l'aide de HttpClient.

Nous allons télécharger le fichier « test.txt » à l'aide de MultipartEntityBuilder :

@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. Obtenir la progression du téléchargement du fichier

Enfin, voyons comment obtenir la progression du téléchargement de fichiers à l' aide de HttpClient .

Dans l'exemple suivant, nous allons étendre HttpEntityWrapper pour gagner en visibilité sur le processus de téléchargement.

Tout d'abord, voici la méthode de téléchargement:

@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(); }

Nous ajouterons également l'interface ProgressListener qui nous permet d'observer la progression du téléchargement:

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

Et voici notre version étendue de HttpEntityWrapper « 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())); } } 

Et la version étendue de FilterOutputStream « 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; } }

Notez que:

  • Lors de l'extension de FilterOutputStream à « CountingOutputStream» - nous surchargons la méthode write () pour compter les octets écrits (transférés)
  • Lors de l'extension de HttpEntityWrapper à « ProgressEntityWrapper» - nous remplaçons la méthode writeTo () pour utiliser notre «CountingOutputStream»

9. Conclusion

Dans ce tutoriel, nous avons illustré les moyens les plus courants d'envoyer des requêtes HTTP POST avec Apache HttpClient 4 .

Nous avons appris comment envoyer une requête POST avec autorisation, comment publier à l'aide de l' API HttpClient fluent et comment télécharger un fichier et suivre sa progression.

L'implémentation de tous ces exemples et extraits de code peut être trouvée dans le projet github.