Pool di connessioni HTTP utilizzando HttpClient

Question

• Come posso creare un pool di connessioni utilizzando HttpClient?
• Devo fare frequenti connessioni allo stesso server. Vale la pena creare una piscina del genere?
• È possibile mantenere connessioni live e usarlo per varie richieste, e in caso affermativo come posso farlo?

Sto sviluppando in Java, utilizzando Apache HTTP Client.

Answer 1

[assumendo Java, Apache e di HttpClient]

Utilizzare un ThreadSafeClientConnManager. Passa una singola istanza globale al costruttore di ogni istanza HttpClient. Non penso che ci sia alcun punto nel mettere insieme gli HttpClients.

Answer 2

Per HttpClient 4x:

ThreadSafeClientConnManager ... gestisce un pool di cliente connessioni ed è in grado di servire le richieste di connessione da più thread di esecuzione.

Le connessioni sono raggruppate su base per tratta. Una richiesta per un percorso per il quale il gestore ha già una connessione permanente disponibile nel pool verrà servita leasing di una connessione dal al pool anziché creare una nuova connessione.

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

Answer 3

ThreadSafeClientConnManager è deprecato ora, utilizzare PoolingClientConnectionManager invece.

Answer 4

PoolingClientConnectionManager è obsoleto. da (versione 4.3) utilizzare PoolingHttpClientConnectionManager.

Answer 5

Questo è un esempio di un Apache 4.3 HttpClient pool di connessioni che non richiedono l'autenticazione:

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 

Answer 6

HttpClient ha già disporre di una connessione pool.So non è necessario crearlo. Basta usarlo.

Answer 7

Ho passato giornate recenti a lavorare su questo, quindi voglio solo condividere con voi alcune conoscenze "conosciute".

Innanzitutto, poiché si tratta dello stesso server, si consiglia di utilizzare un singolo client HTTP per eseguire le richieste. Con l'aiuto di PoolingHttpClientConnectionManager, il tuo client può essere utilizzato per eseguire più richieste contemporaneamente. L'esempio ufficiale dell'esecuzione di richiesta multithread può essere trovato here.

In secondo luogo, HTTP/1.1 (e versioni avanzate di HTTP/1.0) consente ai client HTTP di mantenere aperte le connessioni dopo aver completato le transazioni in modo che possano essere riutilizzate per richieste future. Questo è spesso indicato come Connessione persistente.

Anche allo scopo di riutilizzare il client per più richieste, l'intestazione di risposta da un server include spesso una chiamata di attributo Keep-Alive che contiene la connessione corrente che verrà mantenuta attiva.Oltre a ciò, Apache Http Client fornisce anche un'interfaccia ConnectionKeepAliveStrategy per personalizzare la propria politica per il riutilizzo della connessione.