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

Question

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

I miei requisiti inviano 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 fatto il lavoro, ma vorrei alcune delle vostre opinioni/raccomandazioni.

Answer 1

imho: Apache HTTP Client

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 di evidenziazione:

• Standards base, puro Java, implementazione di versioni HTTP 1.0 e 1.1
  • Piena attuazione 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 tracciamento granulare non standard.
  • Connessioni trasparenti tramite proxy HTTP.
  • Connessioni HTTPS tunnelte tramite proxy HTTP, tramite il metodo CONNECT .
  • Connessioni trasparenti tramite proxy SOCKS (versione 4 & 5) tramite il supporto socket Java nativo .
  • Autenticazione tramite i metodi di base, di digest e di crittografia NTLM (NT Lan Manager).
  • Meccanismo di plug-in per i metodi di autenticazione personalizzati.
  • Modulo POST multiparte per il caricamento di file di grandi dimensioni.
  • Pluggable Secure Sockets implementazioni, rendendo le soluzioni più facili da uso di terzi
  • supporto per la gestione di connessione per l'uso in multi-threaded applicazioni. Supporta l'impostazione delle connessioni totali massime e le connessioni massime per host. Rileva e chiude connessioni stantie.
  • Gestione automatica cookie per la lettura di Set-Cookie: intestazioni dal server e invio di nuovo in un cookie : intestazione quando appropriato.
  • Meccanismo di plug-in per policy cookie personalizzate.
  • Richiedi flussi di output per evitare il buffering di qualsiasi corpo del contenuto tramite lo streaming direttamente al socket su del server.
  • I flussi di input di risposta per leggere in modo efficiente il corpo della risposta tramite lo streaming direttamente dal socket al server .
  • Connessioni persistenti con 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 i timeout della connessione.
  • HttpMethods implementa il modello di comando per consentire le richieste parallele e il riutilizzo efficiente delle connessioni .
  • Il codice sorgente è disponibile gratuitamente con la licenza del software Apache.

Answer 2

Sono d'accordo httpclient è qualcosa di uno standard - ma immagino siete alla ricerca di opzioni in modo ...

Restlet fornisce un client http appositamente progettato per interactong con i servizi web riposante.

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

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

Answer 3

mi sento di raccomandare Apache HttpComponents HttpClient, un successore di Commons HttpClient

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

Answer 4

Sono un po 'parziale a Jersey. Usiamo 1,10 in tutti i nostri progetti e non abbiamo riscontrato problemi che non siamo riusciti a risolvere con questo.

Alcuni motivi per cui mi piace:

• Provider - sapone creato 1.1/1.2 i fornitori in Jersey e hanno eliminato la necessità di utilizzare AXIS ingombrante per il nostro JAX-WS invita
• Filtri - database creato filtri di registrazione per registrare l'intera richiesta (comprese le intestazioni di richiesta/risposta) impedendo la registrazione di informazioni sensibili.
• JAXB - supporta marshalling da/per gli oggetti direttamente dalla richiesta/risposta
• API è facile da usare

A dire il vero, HTTPClient e Jersey sono molto simili nella realizzazione e API. C'è anche un'estensione per Jersey che 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 Cliente: https://blogs.oracle.com/PavelBucek/entry/jersey_client_apache_http_client

Answer 5

Che vi consiglio corn-httpclient. È semplice, veloce e abbastanza 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)); 

esperto di dipendenza

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

Answer 6

Google HTTP Java Client sembra buono per me perché può essere eseguito su Android e App Engine pure.

Answer 7

Voglio menzionare lo Ning Async Http Client Library. Non l'ho mai usato ma il mio collega è entusiasta rispetto ad Apache Http Client, che ho sempre usato in passato. Ero particolarmente interessato ad apprendere che si basa su Netty, l'i/o framework asincrono ad alte prestazioni, con cui sono più familiare e in grande considerazione.