Publication avec HttpClient

Publier avec HttpClient

1. Vue d'ensemble

Dans ce tutoriel -we’ll POST with the 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.

Lectures complémentaires:

Configuration avancée du client

Configurations HttpClient pour les cas d'utilisation avancés.

HttpClient 4 - Envoyer un cookie personnalisé

Comment envoyer des cookies personnalisés avec Apache HttpClient 4.

HttpClient avec SSL

Exemple de configuration de HttpClient avec SSL.

2. POST de base

Tout d'abord, examinons un exemple simple et envoyons une requête POST en utilisantHttpClient.

Nous allons faire un POST avec deux paramètres - «username» et «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();
}

Notez comment nous avons utilisé unList deNameValuePair pour inclure des paramètres dans la requête POST.

3. POST avec autorisation

Voyons ensuite comment effectuer un POST avec des informations d’authentification à l’aide desHttpClient.

Dans l'exemple suivant, nous envoyons une demande 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("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 avec JSON

Voyons maintenant comment envoyer une requête POST avec un corps JSON en utilisant lesHttpClient.

Dans l'exemple suivant, nous envoyons des informationsperson (id, name) au format 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();
}

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

We’re also setting the ContentType header to application/json pour donner au serveur les informations nécessaires sur la représentation du contenu que nous envoyons.

5. POST avec lesHttpClient Fluent API

Ensuite, POST avec l'API Fluent deHttpClient.

Nous allons envoyer une requête avec deux paramètres «username» et «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 Demande en plusieurs parties

Maintenant, POSTONS une requête en plusieurs parties.

Nous publierons unFile, un nom d'utilisateur et un mot de passe en utilisantMultipartEntityBuilder:

@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. Télécharger unFile en utilisantHttpClient

Voyons ensuite comment importer unFile à l'aide desHttpClient.

Nous importerons le fichier «test.txt» en utilisantMultipartEntityBuilder:

@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. RécupérerFile Upload Le progrès

Enfin, voyons comment obtenir la progression de l'importation deFile à l'aide deHttpClient.

Dans l'exemple suivant, nous allons étendre lesHttpEntityWrapper pour gagner en visibilité sur le processus d'importation.

Tout d'abord, voici la méthode d'importation:

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

Nous ajouterons également l'interfaceProgressListener qui nous permet d'observer la progression de l'importation:

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

Et voici notre version étendue deHttpEntityWrapper "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 deFilterOutputStream «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 deFilterOutputStream à «CountingOutputStream” –, nous remplaçons la méthodewrite() pour compter les octets écrits (transférés)
Lors de l'extension deHttpEntityWrapper à «ProgressEntityWrapper” –, nous remplaçons la méthodewriteTo() pour utiliser nos“CountingOutputStream”

9. Conclusion

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

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

L'implémentation de tous ces exemples et extraits de code se trouve dansthe github project.

TOC