Des clients REST pour Java?

comme je l'ai mentionné dans ce fil j'ai tendance à utiliser Jersey qui met en œuvre JAX-RS et est livré avec un client de repos agréable. La bonne chose est que si vous implémentez vos ressources RESTful en utilisant JAX-RS alors le client Jersey peut réutiliser les fournisseurs d'entités tels que pour JAXB/XML/JSON/Atom et ainsi de suite - de sorte que vous pouvez réutiliser les mêmes objets du côté du serveur que vous utilisez sur le test de l'Unité du côté du client.

par exemple ici est un cas d'essai unitaire du Apache Camel project qui recherche des charges utiles XML à partir d'une ressource RESTful (en utilisant les points D'extrémité d'objet JAXB). La méthode de la ressource(uri) est définie dans cette classe de base qui utilise simplement L'API Client De Jersey.

p.ex.

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

BTW j'espère que la future version de JAX-RS ajouter une belle côté client de l'API sur le modèle de celui en Jersey

vous pouvez utiliser le standard Java SE API:

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 les API REST client fournies par les implémentations JAX-RS telles que Jersey. Ces API sont plus faciles à utiliser, mais nécessitent des pots 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, "<customer>...</customer."); 
System.out.println(response); 

pour plus d'information voir:

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

vous pouvez aussi cocher Restlet qui dispose de toutes les fonctionnalités côté client, plus axées sur le repos que les bibliothèques de niveau inférieur comme HttpURLConnection ou Apache Client HTTP (que nous pouvons utiliser comme connecteurs).

meilleures salutations, Jerome Louvel

si vous souhaitez seulement invoquer un service de repos et analyser la réponse, vous pouvez essayer repos assuré

// 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]");

vous pouvez essayer Rapa . Laissez-nous savoir vos commentaires sur le même. Et n'hésitez pas à enregistrer les problèmes ou les fonctionnalités attendues.

je voudrais souligner 2 autres options:

• "Restfulie , basé sur le cadre Web VRaptor, a des implémentations côté serveur et côté client avec un très bon support hypermédia.
• RESTEasy a une JAX-RS proxy client basé sur le la mise en œuvre.

j'ai récemment essayé Retrofit bibliothèque de square, son grand et vous pouvez appeler votre API de repos très facilement. La configuration basée sur l'Annotation nous permet de nous débarrasser de beaucoup de codage de plaques de chaudière.

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

j'écris des analyseurs de SAX XML pour le contenu XML qui analyse le XML dans votre modèle d'objet. Je crois Qu'Axis2 expose aussi des méthodes de Modèles XML - > (L'Axe 1 A CACHÉ cette partie, de manière agaçante). Les générateurs XML sont trivialement simples.

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

Essayer JdkRequest à partir de jcabi-http (je suis développeur). C'est comme ça que ça marche:

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

voir ce billet de blog 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 la modernisation aussi bien. Cela fonctionne bien pour L'utilisation générale de Java 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();

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

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

depuis un moment, j'utilise Resty :

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

On peut trouver quelques exemples ici .

bien qu'il soit simple de créer un client HTTP et de faire un reuest. Mais si vous voulez faire usage de certains clients générés automatiquement, vous pouvez faire usage de WADL pour décrire et générer du code.

vous pouvez utiliser RestDescribe pour générer et compiler WSDL, vous pouvez générer des clients en php, ruby, python, java et C# en utilisant ceci. Il génère du code propre et il y a un bon changement que vous devez modifier un peu après la génération de code, vous pouvez trouver bon documentation sous-jacents et les pensées derrière l'outil ici .

Il y a peu intéressant et utile WADL outils mentionnée sur wintermute.

j'ai écrit une bibliothèque qui établit une correspondance entre une interface java et un service de repos à distance 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);
}

Essayez de regarder les http-repos-client

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

voici un exemple simple:

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 bibliothèque s'occupe de la sérialisation et de la reliure json pour vous.

voici un autre exemple,

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

et un dernier exemple,

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

santé!

exemples de client jersey Rest:

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>

oublie la méthode et passe 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 passer un paramètre et obtenir une réponse de 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, il renvoie une liste que nous acceptons comme liste et la convertissons ensuite en JSON Array puis en Json Array pour List .

If Post Demande passant L'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 "));
    }

vous pouvez utiliser java.net.URL

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

à partir d'une URL, vous pouvez créer une HttpURLConnection qui vous permet d'invoquer specific

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()));
String line = reader.readLine();
while (line != null) {
System.out.println(line);
line = reader.readLine();
}
connection.disconnect();