Comment puis-je réutiliser une connexion HttpClient efficace?

Question

Je fais très souvent HTTP POST (> = 1 / sec) à un point final de l'API et je veux vous assurer que je fais efficacement. Mon but est de réussir ou d'échouer le plus tôt possible, d'autant plus que je code distinct pour une nouvelle tentative POSTs échoué. Il y a une belle page de HttpClient conseils de performance , mais je ne suis pas que si leur mise en œuvre exhaustive tous auront des avantages réels. 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;
  }
}

Ne serait-il judicieux de désactiver la vérification des connexions périmées? Dois-je envisager en utilisant MultiThreadedConnectionManager ? Bien sûr, l'analyse comparative réelle aiderait, mais je voulais vérifier si mon code est sur la bonne voie en premier.

Answer 1

Une grande partie du succès de la performance des connexions HTTP établit la connexion socket. Vous pouvez éviter cela en utilisant « keep-alive » les connexions http. Pour ce faire, il est préférable d'utiliser le protocole HTTP 1.1 et assurez-vous que « Content-Length: xx » est toujours défini dans les demandes et les réponses, « Connecction: proche » est réglé correctement lorsque cela est approprié et correctement donné suite lors de la réception