Le REPOS des clients pour Java?

C'est une vieille question (2008) il y a donc beaucoup plus d'options aujourd'hui qu'il y a eu ensuite:

• Apache CXF a trois différents RESTE les options du Client
• Jersey (mentionné ci-dessus).
• Printemps dispose également de son propre appelé RestTemplate
• Communes Client HTTP construire votre propre pour les anciens projets Java.

mise à JOUR circa 2014:

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

Le nouvel enfant sur le bloc qui fournit NIO soutien (même si honnêtement, je ne pense pas que cela améliore vraiment la performance pour les clients comme c'est le cas des serveurs).

• Apache HTTP Composants (4.2) Couramment adaptateur - Mieux que l'ancien Communes Client HTTP 3 et plus facile à utiliser pour la construction de votre propre client REST. Vous aurez à utiliser quelque chose comme Jackson pour le parsing JSON de soutien, et vous pouvez utiliser HTTP composants URIBuilder de construire ressource Uri similaire à Jersey/JAX-RS Reste client. HTTP composants prend également en charge NIO mais je doute que vous obtiendrez de meilleures performances que le BIO étant donné le peu de demande de la nature de REPOS.

Mise à JOUR en 2016:

• OkHttp - Support de nouveaux protocoles HTTP (SPDY et HTTP2). Fonctionne sur Android. Malheureusement, il ne propose pas un vrai réacteur en boucle en fonction asynchrone en option (voir Ning et HTTP composants ci-dessus). Toutefois, si vous utilisez le plus récent HTTP2 protocole c'est moins un problème (en supposant que nombre de connexions est le problème).
• Rénovation - Auto créer des clients basés sur l'interface talons à l'instar de certaines Jersey et CXF extensions. Utilise OkHttp.
• Apache HttpComponents 5 soi-disant HTTP2 soutien

Une mise en garde sur le choix de HTTP/REST clients. Assurez-vous de vérifier ce que votre cadre de pile pour un client HTTP, comment il fait le filetage, et, idéalement, utiliser le même client si celui-ci offre un. C'est si votre utilisant quelque chose comme Vert.x ou Jouer, vous pouvez essayer d'utiliser son support client à participer à n'importe quel bus ou le réacteur en boucle le cadre fournit... sinon, être préparé pour éventuellement intéressant problèmes de threading.

Vous pouvez utiliser la norme Api Java SE:

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

Ou vous pouvez utiliser le client REST Api fournies par JAX-RS implémentations telles que Jersey. Ces Api sont plus faciles à utiliser, mais exigent d'autres pots sur votre chemin de 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); 

Pour plus d'informations, voir:

• http://bdoughan.blogspot.com/2010/08/creating-restful-web-service-part-55.html

Vous pouvez également vérifier Restlet qui a plein de fonctionnalités côté client, plus de REPOS, que de niveau inférieur bibliothèques comme HttpURLConnection ou Client HTTP Apache (qui nous pouvons utiliser que des connecteurs).

Meilleures salutations,
Jérôme Louvel

J'ai récemment essayé Rénovation de la Bibliothèque de la place, Sa grande et vous pouvez appeler votre API rest très facilement.
Annotation en fonction de la configuration nous permet de nous libérer de beaucoup de chaudière plaque de codage.

J'utilise Apache HTTPClient pour gérer tous les HTTP côté des choses.

J'écris XML SAX analyseurs syntaxiques pour le contenu du fichier XML qui parse le XML dans votre modèle d'objet. Je crois que Axis2 expose également XML -> méthodes de Model (Axe 1 cachait cette partie, fâcheusement). XML générateurs sont carrément simple.

Il ne faut pas longtemps pour le code, et est très efficace, à mon avis.

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

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

Vérifier ce blog pour plus de détails: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

Pour un certain temps maintenant, j'ai été en utilisant Resty:

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

On peut trouver quelques exemples ici.

J'ai écrit une bibliothèque de cartes d'une interface java à distance à un service REST JSON:

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

Des exemples de jersey de Repos client :

L'ajout de la dépendance :

         <!-- 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 et en passant deux paramètres :

          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 en passant un paramètre et l'Obtention d'un Respone de la Liste :

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

Au-Dessus d'Elle Retourne une Liste qui nous acceptent comme une Liste et ensuite de le convertir en Json Tableau Tableau Json à la Liste .

Si une Requête Post en passant Objet Json en 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.writeValueAsString(user));

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

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