¿Cómo puedo reutilizar una conexión HttpClient de manera eficiente?

Question

Estoy haciendo POST HTTP con mucha frecuencia (> = 1/seg) a un punto final API y quiero asegurarme de que lo estoy haciendo de manera eficiente. Mi objetivo es tener éxito o fracasar tan pronto como sea posible, especialmente porque tengo un código separado para volver a intentar las POST fallidas. Hay una bonita página de HttpClient performance tips, pero no estoy seguro de si la implementación exhaustiva de todas ellas tendrá beneficios reales. Aquí está mi código en este momento:

public class Poster { 
    private String url; 
    // re-use our request 
    private HttpClient client; 
    // re-use our method 
    private PostMethod method; 

    public Poster(String url) { 
    this.url = url; 

    // Set up the request for reuse. 
    HttpClientParams clientParams = new HttpClientParams(); 
    clientParams.setSoTimeout(1000); // 1 second timeout. 
    this.client = new HttpClient(clientParams); 
    // don't check for stale connections, since we want to be as fast as possible? 
    // this.client.getParams().setParameter("http.connection.stalecheck", false); 

    this.method = new PostMethod(this.url); 
    // custom RetryHandler to prevent retry attempts 
    HttpMethodRetryHandler myretryhandler = new HttpMethodRetryHandler() { 
     public boolean retryMethod(final HttpMethod method, final IOException exception, int executionCount) { 
     // For now, never retry 
     return false; 
     } 
    }; 

    this.method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, myretryhandler); 
    } 

    protected boolean sendData(SensorData data) { 
    NameValuePair[] payload = { 
     // ... 
    }; 
    method.setRequestBody(payload); 

    // Execute it and get the results. 
    try { 
     // Execute the POST method. 
     client.executeMethod(method); 
    } catch (IOException e) { 
     // unable to POST, deal with consequences here 
     method.releaseConnection(); 
     return false; 
    } 

    // don't release so that it can be reused? 
    method.releaseConnection(); 

    return method.getStatusCode() == HttpStatus.SC_OK; 
    } 
} 

¿Tendría sentido deshabilitar la comprobación de las conexiones rancio? ¿Debería estar mirando usando el MultiThreadedConnectionManager? Por supuesto, el benchmarking real ayudaría, pero quería verificar si mi código está en el camino correcto primero.

Answer 1

Gran parte del impacto en el rendimiento de las conexiones http es establecer la conexión del socket. Puede evitar esto usando conexiones http 'keep-alive'. Para hacer esto, es mejor usar HTTP 1.1 y asegurarse de que "Content-Length: xx" siempre se establece en las solicitudes y respuestas, "Connecction: close" se establece correctamente cuando corresponde y se actúa correctamente cuando se recibe.