Comment puis-je réutiliser une connexion HttpClient de manière efficace?

Question

Je fais des POST HTTP très fréquemment (> = 1/sec) à un point de terminaison API et je veux m'assurer que je le fais de manière efficace. Mon but est de réussir ou d'échouer dès que possible, d'autant plus que j'ai du code séparé pour réessayer les POST échoués. Il y a une belle page de HttpClient performance tips, mais je ne suis pas sûr si les implémenter de manière exhaustive auront tous de réels avantages. Voici mon code en ce moment:

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; 
    } 
} 

Serait-il logique de désactiver la vérification des connexions périmées? Dois-je regarder en utilisant le MultiThreadedConnectionManager? Bien sûr, l'analyse comparative réelle serait utile, mais je voulais d'abord vérifier si mon code était sur la bonne voie.

Answer 1

Une grande partie de l'atteinte des performances des connexions http est l'établissement de la connexion socket. Vous pouvez éviter cela en utilisant des connexions http 'keep-alive'. Pour ce faire, il est préférable d'utiliser HTTP 1.1 et de vous assurer que "Content-Length: xx" est toujours défini dans les requêtes et les réponses, "Connecction: close" est correctement défini et correctement traité lors de la réception.