Wie kann ich eine HttpClient-Verbindung effizient wiederverwenden?

Question

Ich mache HTTP-POSTs sehr häufig (> = 1/Sek.) Zu einem API-Endpunkt, und ich möchte sicherstellen, dass ich es effizient mache. Mein Ziel ist es, so schnell wie möglich erfolgreich zu sein oder zu scheitern, zumal ich separaten Code habe, um fehlgeschlagene POSTs erneut zu versuchen. Es gibt eine nette Seite von , aber ich bin mir nicht sicher, ob die erschöpfende Implementierung von ihnen alle echte Vorteile haben wird. Hier ist mein Code jetzt:

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

Wäre es sinnvoll, die Überprüfung für veraltete Verbindungen zu deaktivieren? Sollte ich mit der MultiThreadedConnectionManager suchen? Natürlich würde das tatsächliche Benchmarking helfen, aber ich wollte zuerst überprüfen, ob mein Code auf der richtigen Spur ist.

Answer 1

Ein Großteil der Leistungseinbußen von HTTP-Verbindungen besteht in der Herstellung der Socket-Verbindung. Sie können dies vermeiden, indem Sie HTTP-Verbindungen "keep-alive" verwenden. Verwenden Sie dazu HTTP 1.1, und stellen Sie sicher, dass "Content-Length: xx" immer in Anforderungen und Antworten festgelegt ist. "Connection: close" wird bei Bedarf korrekt festgelegt und beim Empfang ordnungsgemäß verarbeitet.