Was ist die beste Java-Bibliothek für HTTP POST, GET usw.? [geschlossen]

Was ist die beste Java-Bibliothek für HTTP POST, GET usw. in Bezug auf Leistung, Stabilität, Reife usw.? Gibt es eine bestimmte Bibliothek, die mehr als andere verwendet wird?

Meine Anforderungen sind das Senden von HTTPS-POST-Anforderungen an einen Remote-Server. Ich habe in der Vergangenheit das Paket java.net. * Sowie das Paket org.apache.commons.httpclient. * Verwendet. Beide haben die Arbeit erledigt, aber ich möchte einige Ihrer Meinungen / Empfehlungen.

imho: Apache HTTP Client

Anwendungsbeispiel:

import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.*;
import org.apache.commons.httpclient.params.HttpMethodParams;

import java.io.*;

public class HttpClientTutorial {

  private static String url = "http://www.apache.org/";

  public static void main(String[] args) {
    // Create an instance of HttpClient.
    HttpClient client = new HttpClient();

    // Create a method instance.
    GetMethod method = new GetMethod(url);

    // Provide custom retry handler is necessary
    method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, 
            new DefaultHttpMethodRetryHandler(3, false));

    try {
      // Execute the method.
      int statusCode = client.executeMethod(method);

      if (statusCode != HttpStatus.SC_OK) {
        System.err.println("Method failed: " + method.getStatusLine());
      }

      // Read the response body.
      byte[] responseBody = method.getResponseBody();

      // Deal with the response.
      // Use caution: ensure correct character encoding and is not binary data
      System.out.println(new String(responseBody));

    } catch (HttpException e) {
      System.err.println("Fatal protocol violation: " + e.getMessage());
      e.printStackTrace();
    } catch (IOException e) {
      System.err.println("Fatal transport error: " + e.getMessage());
      e.printStackTrace();
    } finally {
      // Release the connection.
      method.releaseConnection();
    }  
  }
}

Einige Highlight-Funktionen:

• Standardbasiertes, reines Java, Implementierung der HTTP-Versionen 1.0 und 1.1
  • Vollständige Implementierung aller HTTP-Methoden (GET, POST, PUT, DELETE, HEAD, OPTIONS und TRACE) in einem erweiterbaren OO-Framework.
  • Unterstützt die Verschlüsselung mit dem HTTPS-Protokoll (HTTP over SSL).
  • Granulare Konfiguration und Nachverfolgung von Nicht-Standards.
  • Transparente Verbindungen über HTTP-Proxys.
  • Tunnelte HTTPS-Verbindungen über HTTP-Proxys über die CONNECT-Methode.
  • Transparente Verbindungen über SOCKS-Proxys (Version 4 und 5) mit nativer Java-Socket-Unterstützung.
  • Authentifizierung mit Basic, Digest und den verschlüsselenden NTLM-Methoden (NT Lan Manager).
  • Plug-In-Mechanismus für benutzerdefinierte Authentifizierungsmethoden.
  • Mehrteiliges Formular POST zum Hochladen großer Dateien.
  • Steckbare Implementierungen für sichere Sockets, die die Verwendung von Lösungen von Drittanbietern vereinfachen
  • Unterstützung für das Verbindungsmanagement zur Verwendung in Multithread-Anwendungen. Unterstützt das Festlegen der maximalen Gesamtverbindungen sowie der maximalen Verbindungen pro Host. Erkennt und schließt veraltete Verbindungen.
  • Automatische Cookie-Behandlung zum Lesen von Set-Cookie: -Headern vom Server und zum erneuten Senden in einem Cookie: -Header, falls erforderlich.
  • Plug-In-Mechanismus für benutzerdefinierte Cookie-Richtlinien.
  • Fordern Sie Ausgabestreams an, um zu vermeiden, dass Inhaltskörper gepuffert werden, indem Sie direkt zum Socket zum Server streamen.
  • Antworteingabestreams zum effizienten Lesen des Antworttextes durch direktes Streaming vom Socket zum Server.
  • Persistente Verbindungen mit KeepAlive in HTTP / 1.0 und Persistenz in HTTP / 1.1
  • Direkter Zugriff auf den vom Server gesendeten Antwortcode und die Header.
  • Die Möglichkeit, Verbindungszeitlimits festzulegen.
  • HttpMethods implementieren das Befehlsmuster, um parallele Anforderungen und eine effiziente Wiederverwendung von Verbindungen zu ermöglichen.
  • Der Quellcode ist unter der Apache Software License frei verfügbar.

Ich würde Apache HttpComponents HttpClient , einen Nachfolger von Commons HttpClient, empfehlen

Ich würde auch empfehlen, einen Blick auf HtmlUnit zu werfen. HtmlUnit ist ein "GUI-weniger Browser für Java-Programme". http://htmlunit.sourceforge.net/

Ich bin etwas angetan von Jersey . Wir verwenden 1.10 in all unseren Projekten und sind nicht auf ein Problem gestoßen, das wir damit nicht lösen konnten.

Einige Gründe, warum es mir gefällt:

• Anbieter - haben in Jersey Seifen 1.1 / 1.2-Anbieter erstellt und die Verwendung des sperrigen AXIS für unsere JAX-WS-Anrufe überflüssig gemacht
• Filter - Datenbankprotokollierungsfilter erstellt, um die gesamte Anforderung (einschließlich der Anforderungs- / Antwortheader) zu protokollieren und gleichzeitig die Protokollierung vertraulicher Informationen zu verhindern.
• JAXB - unterstützt das Marshalling zu / von Objekten direkt aus der Anforderung / Antwort
• API ist einfach zu bedienen

In Wahrheit sind sich HTTPClient und Jersey in Implementierung und API sehr ähnlich. Es gibt auch eine Erweiterung für Jersey, mit der HTTPClient unterstützt werden kann.

Einige Codebeispiele mit Jersey 1.x: https://blogs.oracle.com/enterprisetechtips/entry/consuming_restful_web_services_with

http://www.mkyong.com/webservices/jax-rs/restful-java-client-with-jersey-client/

HTTPClient mit Jersey Client: https://blogs.oracle.com/PavelBucek/entry/jersey_client_apache_http_client

Ich bin damit einverstanden, dass httpclient so etwas wie ein Standard ist - aber ich denke, Sie suchen nach Optionen, also ...

Restlet bietet einen http-Client, der speziell für die Interaktion mit Restful-Webdiensten entwickelt wurde.

Beispielcode:

    Client client = new Client(Protocol.HTTP);
    Request r = new Request();
    r.setResourceRef("http://127.0.0.1:8182/sample");
    r.setMethod(Method.GET);
    r.getClientInfo().getAcceptedMediaTypes().add(new Preference<MediaType>(MediaType.TEXT_XML));
    client.handle(r).getEntity().write(System.out);

Weitere Informationen finden Sie unter http://www.restlet.org/

Darf ich Ihnen corn-httpclient empfehlen . Es ist einfach, schnell und für die meisten Fälle ausreichend.

HttpForm form = new HttpForm(new URI("http://localhost:8080/test/formtest.jsp"));
//Authentication form.setCredentials("user1", "password");
form.putFieldValue("input1", "your value");
HttpResponse response = form.doPost();
assertFalse(response.hasError());
assertNotNull(response.getData());
assertTrue(response.getData().contains("received " + val));

Maven-Abhängigkeit

<dependency>
    <groupId>net.sf.corn</groupId>
    <artifactId>corn-httpclient</artifactId>
    <version>1.0.0</version>
</dependency>

Google HTTP Java Client sieht für mich gut aus, da es auch auf Android und App Engine ausgeführt werden kann.

Ich möchte das erwähnen Ning Async Http Client Library . Ich habe es nie benutzt, aber mein Kollege schwärmt davon im Vergleich zum Apache Http Client, den ich in der Vergangenheit immer benutzt habe. Ich war besonders daran interessiert zu erfahren, dass es auf Netty basiert , dem leistungsstarken asynchronen I / O-Framework, mit dem ich besser vertraut bin und das ich sehr schätze.