Client REST per Java?

Question

Con JSR 311 e le sue implementazioni abbiamo un potente standard per esporre oggetti Java tramite REST. Tuttavia sul lato client sembra che manchi qualcosa paragonabile ad Apache Axis per SOAP, qualcosa che nasconde il servizio Web e riporta i dati in modo trasparente agli oggetti Java.

Come si creano i client Java RESTful? Usando HTTPConnection e l'analisi manuale del risultato? O clienti specializzati per es. Jersey o Apache CXR?

Answer 1

Questa è una vecchia domanda (2008), quindi ora ci sono molte più opzioni di quante ce ne fossero allora:

• Apache CXF ha tre diversi REST Client opzioni
• Jersey (menzionato sopra).
• Primavera ha anche una propria chiamata RestTemplate
• Client HTTP Commons costruisci il tuo per i più vecchi Progetti Java.

UPDATE circa 2014:

• Async-http-client di Sonatype . Ning Async-http-client .

Il nuovo bambino sul blocco che fornisce supporto NIO (anche se sinceramente non penso che questo migliori le prestazioni per i client come fa con i server).

• Apache HTTP Components (4.2) Adattatore fluente - Meglio del vecchio client HTTP Commons 3 e più facile da usare per creare il tuo client REST. Dovrai utilizzare qualcosa come Jackson per il supporto dell'analisi JSON e puoi utilizzare Componenti HTTP URIBuilder per costruire URI delle risorse simile al client Rest Jersey / JAX-RS . Anche i componenti HTTP supportano NIO ma dubito che otterrai prestazioni migliori rispetto a BIO data la natura di richiesta breve di REST.

AGGIORNAMENTO 2016 :

• OkHttp - Supporta i nuovi protocolli HTTP (SPDY e HTTP2). Funziona su Android. Sfortunatamente non offre una vera opzione asincrona basata su un reattore (vedi sopra i componenti Ning e HTTP). Tuttavia, se si utilizza il protocollo HTTP2 più recente, ciò rappresenta un problema minore (presupponendo che il conteggio delle connessioni sia un problema).
• Retrofit - Crea automaticamente i client in base a stub di interfaccia simili a alcune estensioni Jersey e CXF. Utilizza OkHttp.
• Si suppone che Apache HttpComponents 5 disponga del supporto HTTP2

Un avvertimento sulla scelta dei client HTTP / REST. Assicurati di controllare cosa sta usando il tuo stack di framework per un client HTTP, come funziona il threading e usa idealmente lo stesso client se ne offre uno. Cioè se usi qualcosa come Vert.x o Play potresti voler provare a usare il suo client di supporto per partecipare a qualsiasi circuito bus o reattore fornito dal framework ... altrimenti preparati a problemi di threading potenzialmente interessanti.

Answer 2

Come ho già detto in questa discussione tendo a usare Jersey che implementa JAX-RS e viene fornito con un bel client REST. La cosa bella è che se si implementano le risorse RESTful utilizzando JAX-RS, il client Jersey può riutilizzare i provider di entità come JAXB / XML / JSON / Atom e così via, in modo da poter riutilizzare gli stessi oggetti sul lato server utilizzare nel test dell'unità lato client.

Ad esempio ecco un caso di unit test dal progetto Apache Camel che cerca payload XML da una risorsa RESTful (usando gli oggetti JAXB Endpoint). Il metodo della risorsa (uri) è definito in questa classe di base che utilizza solo l'API client Jersey.

es.

    clientConfig = new DefaultClientConfig();
    client = Client.create(clientConfig);

    resource = client.resource("http://localhost:8080");
    // lets get the XML as a String
    String text = resource("foo").accept("application/xml").get(String.class);        

A proposito, spero che la futura versione di JAX-RS aggiunga una bella API lato client sulla falsariga di quella in Jersey

Answer 3

È possibile utilizzare le API Java SE standard:

private void updateCustomer(Customer customer) { 
    try { 
        URL url = new URL("http://www.example.com/customers"); 
        HttpURLConnection connection = (HttpURLConnection) url.openConnection(); 
        connection.setDoOutput(true); 
        connection.setInstanceFollowRedirects(false); 
        connection.setRequestMethod("PUT"); 
        connection.setRequestProperty("Content-Type", "application/xml"); 

        OutputStream os = connection.getOutputStream(); 
        jaxbContext.createMarshaller().marshal(customer, os); 
        os.flush(); 

        connection.getResponseCode(); 
        connection.disconnect(); 
    } catch(Exception e) { 
        throw new RuntimeException(e); 
    } 
} 

Oppure puoi usare le API client REST fornite dalle implementazioni JAX-RS come Jersey. Queste API sono più facili da usare, ma richiedono barattoli aggiuntivi sul percorso della classe.

WebResource resource = client.resource("http://www.example.com/customers"); 
ClientResponse response = resource.type("application/xml");).put(ClientResponse.class, "<customer>...</customer."); 
System.out.println(response); 

Per ulteriori informazioni, consultare:

• http: //bdoughan.blogspot. com / 2010/08 / creazione-ristoratore-web-service-parte-55.html

Answer 4

Se desideri solo invocare un servizio REST e analizzare la risposta, puoi provare Rest Assured

// Make a GET request to "/lotto"
String json = get("/lotto").asString()
// Parse the JSON response
List<String> winnderIds = with(json).get("lotto.winners.winnerId");

// Make a POST request to "/shopping"
String xml = post("/shopping").andReturn().body().asString()
// Parse the XML
Node category = with(xml).get("shopping.category[0]");

Answer 5

Puoi anche controllare Restlet che ha funzionalità complete sul lato client, più orientate al REST rispetto alle librerie di livello inferiore come come HttpURLConnection o Apache HTTP Client (che possiamo sfruttare come connettori).

Cordiali saluti, Jerome Louvel

Answer 6

Puoi provare Rapa . Facci sapere il tuo feedback sullo stesso. E sentiti libero di registrare problemi o funzionalità previste.

Answer 7

Di recente ho provato Retrofit Library from square, è fantastico e puoi chiamare l'API di riposo molto facilmente. La configurazione basata su annotazioni ci consente di eliminare molta codifica della piastra della caldaia.

Answer 8

Vorrei sottolineare altre 2 opzioni:

• Restfulie , basato sul framework web VRaptor, ha implementazioni sia lato server che client con ottime Supporto hypermedia.
• RESTEasy ha un client basato su proxy JAX-RS implementazione.

Answer 9

Uso Apache HTTPClient per gestire tutto il lato HTTP delle cose.

Scrivo parser XML SAX per il contenuto XML che analizza l'XML nel modello a oggetti. Credo che Axis2 esponga anche XML - > Metodi del modello (l'asse 1 ha nascosto questa parte in modo fastidioso). I generatori XML sono banalmente semplici.

Non ci vuole molto a programmare ed è abbastanza efficiente, secondo me.

Answer 10

OkHttp è leggero e potente se combinato anche con Retrofit. Funziona bene per l'uso generale di Java e su Android.

OkHttp : http://square.github.io/okhttp/

public static final MediaType JSON
    = MediaType.parse("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(JSON, json);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  Response response = client.newCall(request).execute();
  return response.body().string();
}

Retrofit : http://square.github.io/retrofit/

public interface GitHubService {
  @GET("/users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

Answer 11

Prova JdkRequest da jcabi-http (sono uno sviluppatore). Funziona così:

String body = new JdkRequest("http://www.google.com")
  .header("User-Agent", "it's me")
  .fetch()
  .body()

Controlla questo post sul blog per maggiori dettagli: http: // www.yegor256.com/2014/04/11/jcabi-http-intro.html

Answer 12

Poiché nessuno ha menzionato, eccone un altro: Feign , che viene utilizzato da Spring Cloud .

Answer 13

Per un po 'di tempo, sto usando Resty :

JSONResource jsonResource = new Resty (). json (uri);

Si possono trovare alcuni esempi qui .

Answer 14

Anche se è semplice creare un client HTTP e fare un test. Ma se si desidera utilizzare alcuni client generati automaticamente, è possibile utilizzare WADL per descrivere e generare codice.

Puoi utilizzare RestDescribe per generare e compilare WSDL, puoi generare client usando php, ruby, python, java e C #. Genera codice pulito e c'è una buona modifica che devi modificare un po 'dopo la generazione del codice, puoi trovare una buona documentazione e pensieri sottostanti dietro lo strumento qui .

Esistono pochi strumenti WADL interessanti e utili menzionati su wintermute.

Answer 15

Ho scritto una libreria che associa un'interfaccia Java a un servizio REST JSON remoto:

https://github.com/ggeorgovassilis/spring-rest-invoker

public interface BookService {
   @RequestMapping("/volumes")
   QueryResult findBooksByTitle(@RequestParam("q") String q);

   @RequestMapping("/volumes/{id}")
   Item findBookById(@PathVariable("id") String id);
}

Answer 16

Prova a guardare http-rest-client

https://github.com/g00dnatur3/http-rest-client

Ecco un semplice esempio:

RestClient client = RestClient.builder().build();
String geocoderUrl = "http://maps.googleapis.com/maps/api/geocode/json"
Map<String, String> params = Maps.newHashMap();
params.put("address", "beverly hills 90210");
params.put("sensor", "false");
JsonNode node = client.get(geocoderUrl, params, JsonNode.class);

La libreria si occupa della serializzazione e dell'associazione json per te.

Ecco un altro esempio,

RestClient client = RestClient.builder().build();
String url = ...
Person person = ...
Header header = client.create(url, person);
if (header != null) System.out.println("Location header is:" + header.value());

E un ultimo esempio,

RestClient client = RestClient.builder().build();
String url = ...
Person person = client.get(url, null, Person.class); //no queryParams

Cheers!

Answer 17

Esempi di client Rest Jersey:
Aggiunta di dipendenza:

         <!-- jersey -->
    <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-json</artifactId>
        <version>1.8</version>
    </dependency>
   <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-server</artifactId>
        <version>1.8</version>
    </dependency>

<dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-client</artifactId>
    <version>1.8</version>
</dependency>

    <dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20090211</version>
</dependency>

ForGetMethod e passando due parametri:

          Client client = Client.create();
           WebResource webResource1 = client
                        .resource("http://localhost:10102/NewsTickerServices/AddGroup/"
                                + userN + "/" + groupName);

                ClientResponse response1 = webResource1.get(ClientResponse.class);
                System.out.println("responser is" + response1);

GetMethod passando un parametro e ottenendo una risposta dell'elenco:

       Client client = Client.create();

        WebResource webResource1 = client
                    .resource("http://localhost:10102/NewsTickerServices/GetAssignedUser/"+grpName);    
    //value changed
    String response1 = webResource1.type(MediaType.APPLICATION_JSON).get(String.class);

    List <String > Assignedlist =new ArrayList<String>();
     JSONArray jsonArr2 =new JSONArray(response1);
    for (int i =0;i<jsonArr2.length();i++){

        Assignedlist.add(jsonArr2.getString(i));    
    }

In Above It Restituisce un Elenco che stiamo accettando come Elenco e quindi convertendolo in Json Array e quindi Json Array in Elenco.

Se la richiesta di post passa l'oggetto Json come parametro:

   Client client = Client.create();
    WebResource webResource = client
            .resource("http://localhost:10102/NewsTickerServices/CreateJUser");
    // value added

    ClientResponse response = webResource.type(MediaType.APPLICATION_JSON).post(ClientResponse.class,mapper.writeValueAsString(user));

    if (response.getStatus() == 500) {

        context.addMessage(null, new FacesMessage("User already exist "));
    }