Qual è la migliore libreria Java da utilizzare per HTTP POST, GET ecc.? [chiuso]

Qual è la migliore libreria Java da utilizzare per HTTP POST, GET ecc. In termini di prestazioni, stabilità, maturità, ecc.? Esiste una libreria in particolare che viene utilizzata più di altre?

I miei requisiti sono l'invio di richieste POST HTTPS a un server remoto. Ho usato il pacchetto java.net. * In passato così come il pacchetto org.apache.commons.httpclient. *. Entrambi hanno portato a termine il lavoro, ma vorrei alcune delle tue opinioni / raccomandazioni.

imho: client HTTP Apache

esempio di utilizzo:

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

alcune caratteristiche salienti:

• Basato su standard, Java puro, implementazione delle versioni HTTP 1.0 e 1.1
  • Implementazione completa di tutti i metodi HTTP (GET, POST, PUT, DELETE, HEAD, OPTIONS e TRACE) in un framework OO estensibile.
  • Supporta la crittografia con protocollo HTTPS (HTTP su SSL).
  • Configurazione e monitoraggio granulari non standard.
  • Connessioni trasparenti tramite proxy HTTP.
  • Connessioni HTTPS sottoposte a tunnel tramite proxy HTTP, tramite il metodo CONNECT.
  • Connessioni trasparenti tramite proxy SOCKS (versione 4 e 5) utilizzando il supporto socket Java nativo.
  • Autenticazione utilizzando i metodi Basic, Digest e di crittografia NTLM (NT Lan Manager).
  • Meccanismo di plug-in per metodi di autenticazione personalizzati.
  • Modulo multiparte POST per caricare file di grandi dimensioni.
  • Implementazioni di socket protetti collegabili, che semplificano l'utilizzo di soluzioni di terze parti
  • Supporto per la gestione della connessione da utilizzare in applicazioni multi-thread. Supporta l'impostazione del numero massimo di connessioni totali e del numero massimo di connessioni per host. Rileva e chiude le connessioni obsolete.
  • Gestione automatica dei cookie per la lettura delle intestazioni Set-Cookie: dal server e il loro rinvio in un'intestazione Cookie: quando appropriato.
  • Meccanismo di plug-in per le politiche sui cookie personalizzate.
  • Richiedi flussi di output per evitare il buffering di qualsiasi corpo di contenuto trasmettendo in streaming direttamente al socket al server.
  • Flussi di input di risposta per leggere in modo efficiente il corpo della risposta trasmettendo in streaming direttamente dal socket al server.
  • Connessioni persistenti che utilizzano KeepAlive in HTTP / 1.0 e persistenza in HTTP / 1.1
  • Accesso diretto al codice di risposta e alle intestazioni inviate dal server.
  • La possibilità di impostare timeout di connessione.
  • HttpMethods implementa il modello di comando per consentire richieste parallele e un riutilizzo efficiente delle connessioni.
  • Il codice sorgente è disponibile gratuitamente sotto la licenza software Apache.

Consiglierei Apache HttpComponents HttpClient , un successore di Commons HttpClient

Consiglierei anche di dare un'occhiata a HtmlUnit. HtmlUnit è un "browser senza GUI per programmi Java". http://htmlunit.sourceforge.net/

Ho un debole per il Jersey . Usiamo 1.10 in tutti i nostri progetti e non abbiamo riscontrato problemi che non siamo riusciti a risolvere con esso.

Alcuni motivi per cui mi piace:

• Fornitori: hanno creato fornitori di soap 1.1 / 1.2 in Jersey e hanno eliminato la necessità di utilizzare l'ingombrante AXIS per le nostre chiamate JAX-WS
• Filtri: hanno creato filtri di registrazione del database per registrare l'intera richiesta (comprese le intestazioni di richiesta / risposta) impedendo al contempo la registrazione di informazioni sensibili.
• JAXB: supporta il marshalling da / verso oggetti direttamente dalla richiesta / risposta
• L'API è facile da usare

In verità, HTTPClient e Jersey sono molto simili nell'implementazione e nell'API. C'è anche un'estensione per Jersey che gli consente di supportare HTTPClient.

Alcuni esempi di codice con 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 con Jersey Client: https://blogs.oracle.com/PavelBucek/entry/jersey_client_apache_http_client

Sono d'accordo che httpclient è qualcosa di uno standard, ma immagino che tu stia cercando opzioni quindi ...

Restlet fornisce un client http appositamente progettato per interagire con i servizi web Restful.

Codice di esempio:

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

Vedi http://www.restlet.org/ per maggiori dettagli

Posso consigliarti corn-httpclient . È semplice, veloce e sufficiente per la maggior parte dei casi.

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

dipendenza da esperti

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

Il client Java HTTP di Google mi sembra buono perché può essere eseguito anche su Android e App Engine.

Voglio menzionare la libreria client Http Ning Async . Non l'ho mai usato ma il mio collega ne è entusiasta rispetto al client Http Apache, che ho sempre usato in passato. Mi ha particolarmente interessato apprendere che si basa su Netty , il framework i / o asincrono ad alte prestazioni, con il quale ho più familiarità e ho una grande stima.