web-dev-qa-db-fra.com

Regroupement de connexions HTTP à l'aide de HttpClient

  • Comment puis-je créer un pool de connexions à l'aide de HttpClient?
  • Je dois établir des connexions fréquentes avec le même serveur. Vaut-il la peine de créer un tel pool?
  • Est-il possible de conserver des connexions en direct et de l'utiliser pour diverses demandes, et si oui, comment le faire?

Je développe en Java, en utilisant Apache HTTP Client .

javahttpclienthttpconnectionpooling
26
John

[en supposant Java et HttpClient d'Apache]

Utilisez un ThreadSafeClientConnManager . Passez une seule instance globale au constructeur de chaque instance HttpClient. Je ne pense pas qu'il soit inutile de regrouper les HttpClients eux-mêmes.

16
Tom Anderson

PoolingClientConnectionManager est obsolète maintenant. à partir de (version 4.3), utilisez PoolingHttpClientConnectionManager.

20
pssh

J'ai passé ces derniers jours à travailler sur ce sujet, alors je veux juste partager avec vous quelques connaissances "connues de tous".

Tout d'abord, comme vous traitez avec le même serveur, il est recommandé d'utiliser un seul client HTTP pour exécuter vos requêtes. Avec l'aide de PoolingHttpClientConnectionManager, votre client peut être utilisé pour exécuter plusieurs requêtes simultanément. L'exemple officiel de l'exécution d'une requête multithread peut être trouvé ici .

Deuxièmement, HTTP/1.1 (et les versions améliorées de HTTP/1.0) permettent aux clients HTTP de garder les connexions ouvertes une fois les transactions terminées afin de pouvoir les réutiliser pour de futures demandes. Ceci est souvent appelé Connexion persistante .

Toujours dans le but de réutiliser le client pour plusieurs demandes, l'en-tête de réponse d'un serveur inclut souvent un appel d'attribut Keep-Alive contenant l'heure à laquelle la connexion actuelle sera maintenue. En plus de cela, Apache Http Client vous fournit également une interface ConnectionKeepAliveStrategypour personnaliser votre propre politique de réutilisation de la connexion.

20
eriknguyen

ThreadSafeClientConnManager est obsolète maintenant, utilisez plutôt PoolingClientConnectionManager .

15
Manoj N V

Pour HttpClient 4x:

ThreadSafeClientConnManager ... gère un pool de connexions client et est capable de traiter les demandes de connexion à partir de plusieurs threads d'exécution.

Les connexions sont regroupées par itinéraire . Une demande de route pour laquelle le gestionnaire dispose déjà d'une connexion persistante disponible dans le pool sera traitée en louant une connexion à partir du pool plutôt que de créer un toute nouvelle connexion.

http://hc.Apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html

8
serg.nechaev

Voici un exemple d'un pool de connexions Apache HttpClient 4.3 qui ne nécessite pas d'authentification:

public class PoolOfHttpConnections{
   static String[] urisToGet = {"http://www.site1.com", "http://www.site2.com"};

    public static void main(String[] args) throws Exception {
           CloseableHttpClient httpclient = HttpClients.createDefault();
           // create a thread for each link
           GetThread[] threads = new GetThread[urisToGet.length];
           for (int i = 0; i < threads.length; i++) {
               HttpGet httpget = new HttpGet(urisToGet[i]);
               threads[i] = new GetThread(httpClient, httpget);
           }

           // start the threads
           for (int j = 0; j < threads.length; j++) {
               threads[j].start();
           }
           // join the threads
           for (int j = 0; j < threads.length; j++) {
               threads[j].join();
           }
    } //end main

    private static class GetThread extends Thread {

            private final CloseableHttpClient httpClient;
            private final HttpContext context;
            private final HttpGet httpget;

            public GetThread(CloseableHttpClient httpClient, HttpGet httpget) {
                   this.httpClient = httpClient;
                   this.context = HttpClientContext.create();
                   this.httpget = httpget;
            }

            @Override
            public void run() {
                   try {
                       CloseableHttpResponse response = httpClient.execute(httpget, context);
                       try {
                           HttpEntity entity = response.getEntity();
                           System.out.println("----------------------------------------");
                           Date date = new Date();
                           System.out.println("Beginning*******************");
                           System.out.println(date.toString());
                           System.out.println("There are "+urisToGet.length+" threads running in parallel!");
                           System.out.println(response.getStatusLine());
                           if (entity != null) {
                              System.out.println("Response content length: " + entity.getContentLength());
                           }
                           System.out.println(EntityUtils.toString(entity));
                           EntityUtils.consume(entity);
                       } finally {
                         response.close();
                         System.out.println("End*******************");
                       }
                   } catch (ClientProtocolException ex) {
                          // Handle protocol errors
                   } catch (IOException ex) {
                          // Handle I/O errors
                   }
            }
    } /*end private class*/  }//end public class PoolOfHttpConnections
2
Octavian Ionel