Appel RESTful en Java

Mise à jour: Cela fait presque 5 ans que j'ai écrit la réponse ci-dessous; aujourd'hui, j'ai une perspective différente.

99% du temps lorsque les gens utilisent le terme REST, ils veulent vraiment dire HTTP; ils se soucient moins des "ressources", des "représentations", des "transferts d'état", des "interfaces uniformes", des "hypermédias" ou de toute autre contrainte ou aspect du style d'architecture REST identifié par Fielding. Les abstractions fournies par divers frameworks REST sont donc déroutantes et peu serviable.

Donc: vous souhaitez envoyer des requêtes HTTP en utilisant Java en 2015. Vous voulez une API claire, expressive, intuitive, idiomatique, simple. Ce qu'il faut utiliser? Je n'utilise plus Java, mais depuis quelques années, la bibliothèque cliente Java HTTP qui a semblé la plus prometteuse et la plus intéressante est OkHttp. Check it out.

Vous pouvez certainement interagir avec les services Web RESTful en utilisant URLConnectionou HttpClient pour coder les requêtes HTTP.

Cependant, c'est généralement plus souhaitable d'utiliser une bibliothèque ou un framework qui fournit une API plus simple et plus sémantique spécialement conçue à cet effet. Cela facilite l'écriture, la lecture et le débogage du code et réduit la duplication des efforts. Ces frameworks implémentent généralement d'excellentes fonctionnalités qui ne sont pas nécessairement présentes ou faciles à utiliser dans les bibliothèques de niveau inférieur, telles que la négociation de contenu, la mise en cache et l'authentification.

Certaines des options les plus matures sont Jersey, RESTEasy, et Restlet.

Je suis le plus familier avec Restlet, et Jersey, regardons comment nous ferions une requête POST avec les deux API.

Exemple de maillot

Form form = new Form();
form.add("x", "foo");
form.add("y", "bar");

Client client = ClientBuilder.newClient();

WebTarget resource = client.target("http://localhost:8080/someresource");

Builder request = resource.request();
request.accept(MediaType.APPLICATION_JSON);

Response response = request.get();

if (response.getStatusInfo().getFamily() == Family.SUCCESSFUL) {
    System.out.println("Success! " + response.getStatus());
    System.out.println(response.getEntity());
} else {
    System.out.println("ERROR! " + response.getStatus());    
    System.out.println(response.getEntity());
}

Exemple de restlet

Form form = new Form();
form.add("x", "foo");
form.add("y", "bar");

ClientResource resource = new ClientResource("http://localhost:8080/someresource");

Response response = resource.post(form.getWebRepresentation());

if (response.getStatus().isSuccess()) {
    System.out.println("Success! " + response.getStatus());
    System.out.println(response.getEntity().getText());
} else {
    System.out.println("ERROR! " + response.getStatus());
    System.out.println(response.getEntity().getText());
}

Bien sûr, les demandes GET sont encore plus simples, et vous pouvez également spécifier des choses comme les balises d'entité et les en-têtes Accept, mais j'espère que ces exemples sont utilement non triviaux mais pas trop complexes.

Comme vous pouvez le voir, Restlet et Jersey ont un client similaire API. Je crois qu'ils ont été développés à peu près à la même époque et se sont donc influencés mutuellement.

Je trouve que l'API Restlet est un peu plus sémantique, et donc un peu plus claire, mais YMMV.

Comme je l'ai dit, je suis le plus familier avec Restlet, je l'ai utilisé dans de nombreuses applications depuis des années, et j'en suis très content. C'est un cadre très mature, robuste, simple, efficace, actif et bien pris en charge. Je ne peux pas parler à Jersey ou RESTEasy, mais mon impression est qu'ils sont tous les deux aussi solides choix.

C'est très compliqué en java, c'est pourquoi je suggérerais d'utiliser Spring RestTemplate abstraction:

String result = 
restTemplate.getForObject(
    "http://example.com/hotels/{hotel}/bookings/{booking}",
    String.class,"42", "21"
);

Référence:

• Blog de printemps: Repos au printemps 3 (RestTemplate)
• Référence Spring: Accès à RESTful services sur le Client
• JavaDoc: RestTemplate

Si vous avez juste besoin de faire un simple appel à un service REST à partir de java, vous utilisez quelque chose le long de cette ligne

/*
 * Stolen from http://xml.nig.ac.jp/tutorial/rest/index.html
 * and http://www.dr-chuck.com/csev-blog/2007/09/calling-rest-web-services-from-java/
*/
import java.io.*;
import java.net.*;

public class Rest {

    public static void main(String[] args) throws IOException {
        URL url = new URL(INSERT_HERE_YOUR_URL);
        String query = INSERT_HERE_YOUR_URL_PARAMETERS;

        //make connection
        URLConnection urlc = url.openConnection();

        //use post mode
        urlc.setDoOutput(true);
        urlc.setAllowUserInteraction(false);

        //send query
        PrintStream ps = new PrintStream(urlc.getOutputStream());
        ps.print(query);
        ps.close();

        //get result
        BufferedReader br = new BufferedReader(new InputStreamReader(urlc
            .getInputStream()));
        String l = null;
        while ((l=br.readLine())!=null) {
            System.out.println(l);
        }
        br.close();
    }
}

Il y a plusieurs API RESTful autour. Je recommanderais Jersey;

Https://jersey.java.net/

La documentation de l'API client est ici;

Https://jersey.java.net/documentation/latest/index.html

Mise à Jour
L'emplacement des documents OAuth dans le commentaire ci-dessous est un lien mort et a été déplacé vers https://jersey.java.net/nonav/documentation/latest/security.html#d0e12334

Je veux partager mon expérience personnelle, en appelant un REST WS avec un appel Post JSON:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.URL;
import java.net.URLConnection;

public class HWS {

    public static void main(String[] args) throws IOException {
        URL url = new URL("INSERT YOUR SERVER REQUEST");
        //Insert your JSON query request
        String query = "{'PARAM1': 'VALUE','PARAM2': 'VALUE','PARAM3': 'VALUE','PARAM4': 'VALUE'}";
        //It change the apostrophe char to double colon char, to form a correct JSON string
        query=query.replace("'", "\"");

        try{
            //make connection
            URLConnection urlc = url.openConnection();
            //It Content Type is so importan to support JSON call
            urlc.setRequestProperty("Content-Type", "application/xml");
            Msj("Conectando: " + url.toString());
            //use post mode
            urlc.setDoOutput(true);
            urlc.setAllowUserInteraction(false);

            //send query
            PrintStream ps = new PrintStream(urlc.getOutputStream());
            ps.print(query);
            Msj("Consulta: " + query);
            ps.close();

            //get result
            BufferedReader br = new BufferedReader(new InputStreamReader(urlc.getInputStream()));
            String l = null;
            while ((l=br.readLine())!=null) {
                Msj(l);
            }
            br.close();
        } catch (Exception e){
            Msj("Error ocurrido");
            Msj(e.toString());
        }
    }

    private static void Msj(String texto){
        System.out.println(texto);
    }
}

Vous pouvez vérifier le CXF. Vous pouvez visiter l'article JAX-RS ici

Appeler est aussi simple que ceci (citation):

BookStore store = JAXRSClientFactory.create("http://bookstore.com", BookStore.class);
// (1) remote GET call to http://bookstore.com/bookstore
Books books = store.getAllBooks();
// (2) no remote call
BookResource subresource = store.getBookSubresource(1);
// {3} remote GET call to http://bookstore.com/bookstore/1
Book b = subresource.getDescription();

En Effet, c'est "très compliqué en Java":

À Partir de: https://jersey.java.net/documentation/latest/client.html

Client client = ClientBuilder.newClient();
WebTarget target = client.target("http://foo").path("bar");
Invocation.Builder invocationBuilder = target.request(MediaType.TEXT_PLAIN_TYPE);
Response response = invocationBuilder.get();

La solution la plus simple sera d'utiliser la bibliothèque client http Apache. reportez-vous à l'exemple de code suivant.. ce code utilise la sécurité de base pour l'authentification.

Ajouter la dépendance suivante.

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.4</version>
</dependency>

CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
Credentials credentials = new UsernamePasswordCredentials("username", "password");
credentialsProvider.setCredentials(AuthScope.ANY, credentials);
HttpClient client = HttpClientBuilder.create().setDefaultCredentialsProvider(credentialsProvider).build();
HttpPost request = new HttpPost("https://api.plivo.com/v1/Account/MAYNJ3OT/Message/");HttpResponse response = client.execute(request);
    // Get the response
    BufferedReader rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
    String line = "";
    while ((line = rd.readLine()) != null) {    
    textView = textView + line;
    }
    System.out.println(textView);

Vous pouvez utiliser Client Http asynchrone (La bibliothèque prend également en charge le protocole WebSocket) comme ceci:

    String clientChannel = UriBuilder.fromPath("http://localhost:8080/api/{id}").build(id).toString();

    try (AsyncHttpClient asyncHttpClient = new AsyncHttpClient())
    {
        BoundRequestBuilder postRequest = asyncHttpClient.preparePost(clientChannel);
        postRequest.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON);
        postRequest.setBody(message.toString()); // returns JSON
        postRequest.execute().get();
    }