Les clients REST pour Java?

Avec JSR 311 et ses implémentations, nous disposons d’un standard puissant pour exposer les objects Java via Rest. Cependant, du côté du client, il semble qu’il manque quelque chose comparable à Apache Axis for SOAP – quelque chose qui cache le service Web et recycle les données de manière transparente sur les objects Java.

Comment créez-vous des clients Java RESTful? Utilisation de HTTPConnection et parsing manuelle du résultat? Ou des clients spécialisés pour, par exemple, Jersey ou Apache CXR?

C’est une vieille question (2008), il y a donc beaucoup plus d’options maintenant qu’il n’y en avait:

  • Apache CXF a trois options de client REST différentes
  • Jersey (mentionné ci-dessus).
  • Le spring a aussi son propre appelé RestTemplate
  • Le client HTTP Commons construit vos propres projets Java plus anciens.

MISE À JOUR vers 2014:

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

Le nouveau gamin sur le bloc qui fournit le support NIO (bien que je ne pense pas que cela améliore vraiment les performances des clients comme les serveurs).

  • Composants HTTP Apache (4.2) Adaptateur courant – Mieux qu’un ancien client HTTP Commons 3 et plus facile à utiliser pour créer votre propre client REST. Vous devrez utiliser quelque chose comme le support de l’ parsing syntaxique Jackson pour JSON et vous pouvez utiliser les composants HTTP URIBuilder pour créer des URI de ressources similaires à celles du client Rest / Jersey JAX-RS. Les composants HTTP prennent également en charge NIO, mais je doute que vous obtiendrez de meilleures performances que BIO étant donné la nature de demande courte de REST.

MISE À JOUR 2016 :

  • OkHttp – Prend en charge les nouveaux protocoles HTTP (SPDY et HTTP2). Fonctionne sur Android. Malheureusement, il n’offre pas une véritable option asynchrone basée sur la boucle du réacteur (voir les composants Ning et HTTP ci-dessus). Cependant, si vous utilisez le protocole HTTP2 le plus récent, le problème est moindre (en supposant que le nombre de connexions pose problème).
  • Rénovation : créera automatiquement des clients basés sur des stubs d’interface similaires à certaines extensions de Jersey et CXF. Utilise OkHttp.
  • Apache HttpComponents 5 aura supposément un support HTTP2

Une mise en garde sur le choix des clients HTTP / REST. Assurez-vous de vérifier ce que votre stack d’infrastructure utilise pour un client HTTP, comment cela fonctionne et, idéalement, utilisez le même client s’il en propose un. C’est-à-dire que si vous utilisez quelque chose comme Vert.x ou Play, vous pouvez essayer d’utiliser son client de sauvegarde pour participer à la boucle de bus ou de réacteur fournie par la structure …

Comme je l’ai mentionné dans ce fil, j’ai tendance à utiliser Jersey qui implémente JAX-RS et qui est livré avec un bon client REST. La bonne chose est que si vous implémentez vos ressources RESTful en utilisant JAX-RS, le client Jersey peut réutiliser les fournisseurs d’entités tels que JAXB / XML / JSON / Atom et ainsi de suite – afin de pouvoir réutiliser les mêmes objects utiliser sur le test de l’unité côté client.

Par exemple, voici un cas de test unitaire du projet Apache Camel qui recherche les données utiles XML à partir d’une ressource RESTful (à l’aide des points de terminaison de l’object JAXB). La méthode resource (uri) est définie dans cette classe de base qui utilise simplement l’API client Jersey.

par exemple

clientConfig = new DefaultClientConfig(); client = Client.create(clientConfig); resource = client.resource("http://localhost:8080"); // lets get the XML as a Ssortingng Ssortingng text = resource("foo").accept("application/xml").get(Ssortingng.class); 

BTW j’espère que la future version de JAX-RS ajoute une belle API côté client sur le modèle de celle de Jersey

Vous pouvez utiliser les 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); } } 

Vous pouvez également utiliser les API client REST fournies par les implémentations JAX-RS telles que Jersey. Ces API sont plus faciles à utiliser, mais nécessitent des jars supplémentaires sur votre chemin de classe.

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

Pour plus d'informations, voir:

Vous pouvez également vérifier Restlet qui dispose de toutes les fonctionnalités côté client, plus orienté REST que les bibliothèques de niveau inférieur telles que HttpURLConnection ou Apache HTTP Client (que nous pouvons utiliser comme connecteurs).

Cordialement, Jerome Louvel

Si vous souhaitez uniquement appeler un service REST et parsingr la réponse, vous pouvez essayer Rest Assured

 // Make a GET request to "/lotto" Ssortingng json = get("/lotto").asSsortingng() // Parse the JSON response List winnderIds = with(json).get("lotto.winners.winnerId"); // Make a POST request to "/shopping" Ssortingng xml = post("/shopping").andReturn().body().asSsortingng() // Parse the XML Node category = with(xml).get("shopping.category[0]"); 

Tu pourrais essayer Rapa . Faites-nous savoir vos commentaires à propos de la même chose. Et n’hésitez pas à enregistrer les problèmes ou les fonctionnalités attendues.

J’aimerais signaler 2 autres options:

  • Restfulie , basé sur le framework Web VRaptor, a des implémentations côté serveur et client avec un très bon support Hypermedia.
  • RESTEasy a une implémentation client basée sur un proxy JAX-RS .

J’ai récemment essayé Retrofit Library de square, c’est génial et vous pouvez appeler votre API de repos très facilement. La configuration basée sur les annotations nous permet de supprimer beaucoup de codage de la plaque de la chaudière.

J’utilise Apache HTTPClient pour gérer tout le côté HTTP des choses.

J’écris des parsingurs XML SAX pour le contenu XML qui parsing le XML dans votre modèle d’object. Je crois qu’Axis2 expose également les méthodes XML -> Model (Axis 1 a caché cette partie, de manière agaçante). Les générateurs XML sont très simples.

Cela ne prend pas longtemps pour coder, et est tout à fait efficace, à mon avis.

Essayez JdkRequest partir de jcabi-http (je suis développeur). Voilà comment cela fonctionne:

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

Consultez cet article pour plus de détails: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

OkHttp est léger et puissant lorsqu’il est combiné avec Retrofit. Cela fonctionne bien pour une utilisation Java générale ainsi que sur Android.

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

 public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8"); OkHttpClient client = new OkHttpClient(); Ssortingng post(Ssortingng url, Ssortingng 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().ssortingng(); } 

Rénovation : http://square.github.io/retrofit/

 public interface GitHubService { @GET("/users/{user}/repos") Call> listRepos(@Path("user") Ssortingng user); } 

Comme personne ne l’a mentionné, en voici un autre: Feign , qui est utilisé par Spring Cloud .

Depuis quelque temps, j’utilise Resty :

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

On peut trouver quelques exemples ici .

Bien que ce soit simple pour créer un client HTTP et faire un retour. Mais si vous voulez utiliser certains clients générés automatiquement, vous pouvez utiliser WADL pour décrire et générer du code.

Vous pouvez utiliser RestDescribe pour générer et comstackr WSDL, vous pouvez générer des clients en php, ruby, python, java et C # en utilisant ceci. Il génère un code propre et il y a un bon changement que vous devez le modifier un peu après la génération du code, vous pouvez trouver une bonne documentation et des idées sous-jacentes derrière l’outil ici .

Il y a peu d’ outils WADL intéressants et utiles mentionnés sur wintermute.

J’ai écrit une bibliothèque qui associe une interface Java à un service JSON REST distant:

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

 public interface BookService { @RequestMapping("/volumes") QueryResult findBooksByTitle(@RequestParam("q") Ssortingng q); @RequestMapping("/volumes/{id}") Item findBookById(@PathVariable("id") Ssortingng id); } 

Essayez de regarder http-rest-client

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

Voici un exemple simple:

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

La bibliothèque prend en charge la sérialisation et la liaison json pour vous.

Voici un autre exemple,

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

Et un dernier exemple,

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

À votre santé!

Exemples de client Reste Jersey:
Ajout de dépendance:

    com.sun.jersey jersey-json 1.8   com.sun.jersey jersey-server 1.8   com.sun.jersey jersey-client 1.8   org.json json 20090211  

ForGetMethod et deux parameters de passage:

  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 passe un paramètre et obtient une réponse de la liste:

  Client client = Client.create(); WebResource webResource1 = client .resource("http://localhost:10102/NewsTickerServices/GetAssignedUser/"+grpName); //value changed Ssortingng response1 = webResource1.type(MediaType.APPLICATION_JSON).get(Ssortingng.class); List  Assignedlist =new ArrayList(); JSONArray jsonArr2 =new JSONArray(response1); for (int i =0;i 

In Above It Retourne une liste que nous acceptons comme une liste, puis la convertit en Json Array puis en Json Array to List.

Si Post Request envoie un object Json en tant que paramètre:

  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.writeValueAsSsortingng(user)); if (response.getStatus() == 500) { context.addMessage(null, new FacesMessage("User already exist ")); } 

Vous pouvez utiliser java.net.URL

 public class URL { public URL(java.lang.Ssortingng s) throws java.net.MalformedURLException {} public java.net.URLConnection openConnection() throws java.io.IOException {} ... } 

A partir d’une URL, vous pouvez créer un HttpURLConnection qui vous permet d’appeler des informations spécifiques.

 requests. Here's an example of doing a simple GET request: URL url = new URL("http://example.com/customers/1"); connection = (HttpURLConnection) getUrl.openConnection(); connection.setRequestMethod("GET"); connection.setRequestProperty("Accept", "application/xml"); if (connection.getResponseCode() != 200) { throw new RuntimeExceptioin("Operation failed: " + connection.getResponseCode()); } System.out.println("Content-Type: " + connection.getContentType()); BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream())); Ssortingng line = reader.readLine(); while (line != null) { System.out.println(line); line = reader.readLine(); } connection.disconnect();