java - Agrupación de conexiones HTTP utilizando HttpClient

httpconnection pooling

Question

• ¿Cómo puedo crear un grupo de conexiones usando HttpClient?
• Tengo que hacer conexiones frecuentes al mismo servidor. ¿Vale la pena crear tal grupo?
• ¿Es posible mantener conexiones en vivo y usarlas para varias solicitudes? En caso afirmativo, ¿cómo puedo hacerlo?

Estoy desarrollando en Java, usando Apache HTTP Client .

Answer 1

Este es un ejemplo de un grupo de conexiones de Apache HttpClient 4.3 que no requieren autenticación:

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 2

He pasado los últimos días trabajando en esto, así que solo quiero compartir algunos conocimientos "conocidos por todos" con ustedes.

En primer lugar, ya que está tratando con el mismo servidor, se recomienda utilizar un único cliente HTTP para ejecutar sus solicitudes. Con la ayuda de PoolingHttpClientConnectionManager , su cliente puede ser usado para ejecutar múltiples solicitudes al mismo tiempo. El ejemplo oficial de ejecución de solicitud multiproceso se puede encontrar here .

En segundo lugar, HTTP / 1.1 (y las versiones mejoradas de HTTP / 1.0) permiten que los clientes HTTP mantengan las conexiones abiertas después de que se completen las transacciones para que puedan reutilizarse para futuras solicitudes. Esto se refiere a menudo como conexión persistente .

También con el propósito de reutilizar al cliente para múltiples solicitudes, el encabezado de respuesta de un servidor a menudo incluye un atributo llamado Keep-Alive que contiene el tiempo en que la conexión actual se mantendrá activa. Además de eso, Apache Http Client también le proporciona una interfaz ConnectionKeepAliveStrategy para personalizar su propia política para reutilizar la conexión.

Answer 3

HttpClient ya tiene un grupo de conexión. Por lo tanto, no es necesario crearlo. Sólo úsalo.

Answer 4

Para HttpClient 4x:

ThreadSafeClientConnManager ... administra un grupo de conexiones de clientes y puede atender solicitudes de conexión desde múltiples subprocesos de ejecución.

Las conexiones se agrupan por ruta . Una solicitud de una ruta para la cual el administrador ya tiene una conexión persistente disponible en el grupo se atenderá mediante el arrendamiento de una conexión del grupo en lugar de crear una nueva conexión.

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

Answer 5

ThreadSafeClientConnManager está en desuso ahora, use PoolingClientConnectionManager en PoolingClientConnectionManager lugar.

Answer 6

[asumiendo Java y HttpClient de Apache]

Utilice un ThreadSafeClientConnManager . Pase una única instancia global al constructor de cada instancia de HttpClient. No creo que tenga sentido agrupar a los HttpClients.

Answer 7

PoolingClientConnectionManager está en PoolingClientConnectionManager ahora. desde (versión 4.3) use PoolingHttpClientConnectionManager .