Consumer les web services RESTFull dans une application Java

Consumer les web services RESTFull dans une
application Java
L’objectif de ces travaux est de vous montrer comment consommer un service web RESTFul à partir
d'une application JAVA. L'idée est d'ouvrir une connection par HTTP au serveur et d'effectuer des
opérations sur les ressources exposées en lecture (GET), écriture (DELETE, POST, PUT).
Nous utiliserons la librairie Apache Components qui permet d'effectuer des requetes HTTP à partir
d'une application Java. Rendez vous sur le site du projet et téléchargez la librairie sur votre poste de
travail.
Cette librairie dépend d’autres librairies, et toutes les dépendances sont fournies dans le
dossier téléchargé ; ajoutez les tous en référence à votre projet.
Bonne pratique : Créez un dossier libs dans l’arborescence de votre projet puis placez les jars à
importer dans ce dossier. En faisant ainsi, vous n’aurez pas de problème de références si jamais
vous déplacez le projet vers un autre dossier ou si vous le passez à un collègue ou un prof.
• Créez un projet Java Application sous Netbeans
• Ajoutez une rérérence à la librairie que vous téléchargée précedemment
Faites bouton doigt sur Libraries dans l’arborescence de votre projet sur Netbeans è Add Jar/Folder
• Ouvrez la classe SimpleClient qui a été généré à la création du projet, modifiez cette classe afin
qu'elle puisse accéder en lecture à la ressource "categorie" de votre service.
1
private void sendPost() throws Exception {
HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost(url);
// add header
post.setHeader("Content-Type", "application/json");
JSONObject obj = new JSONObject();
obj.put("nom", "Mathématique");
obj.put("description", "Livres de mathématiques pour tous les n
StringEntity entity = new StringEntity(obj.toJSONString());
post.setEntity(entity);
HttpResponse response = client.execute(post);
System.out.println("\nSending 'POST' request to URL : " + url);
System.out.println("Post parameters : " + post.getEntity());
System.out.println("Response Code : " +
response.getStatusLine().getStatusCode());
BufferedReader rd = new BufferedReader(
new InputStreamReader(response.getEntity().getContent()
StringBuffer result = new StringBuffer();
String line = "";
while ((line = rd.readLine()) != null) {
result.append(line);
}
System.out.println(result.toString());
}
• Exécutez le code et vérifiez que la représentation de la ressource s'affiche dans la console de
Netbeans
• Faites appel maintenant à vos connaissances XML pour parser la réponse du serveur afin de
reconstruire des objets Java
Voici quelques liens qui pourront vous inspirer
1. Avec SAX : http://java.developpez.com/faq/xml/?page=sax
2
2. Avec DOM : http://www.mkyong.com/java/how-to-create-xml-file-in-java-dom/
3. Ou JDOM : http://cynober.developpez.com/tutoriel/java/xml/jdom/
• Modifiez la requête précédente pour avoir une représentation JSON de la ressource.
request.addHeader("Accept","application/json");
• Exécutez à nouveau le code et vérifiez que la représentation de la ressource a changé.
• Traitez la réponse JSON obtenue
Pour Java, il existe une variété de librairies permettant de traiter les représentations JSON
(http://json.org ), pour ce TP nous utiliserons la librairie json-simple que vous pourrez télécharger ici.
Après avoir téléchargé la librairie, ajoutez une référence à votre projet comme précédemment.
Une représentation JSON peut être de deux types : JsonObjet ou JsonArray
Il est necessaire de connaitre au préalable le format de la représentation avant de pouvoir la traiter.
//Pour créer un Json Array
JSONArray j = (JSONArray)JSONValue.parse(result.toString());
//Pour créer un Json Object
JSONObject j = (JSONObject )JSONValue.parse(result.toString());
//Pour un code plus propre
try
{
Object o = JSONValue.parse(result.toString());
if (o instanceof JSONObject)
{
JSONObject j = (JSONObject )JSONValue.parse(result.toString());
}
else{
JSONArray j = (JSONArray)JSONValue.parse(result.toString());
}
}
catch(Exception e) {
//Si une exception est levée la représentation n'est pas valide
}
Comme on l'a vu en cours le format JSON est assez simple et très facile à manipuler, c'est une
représentation clefs/valeur. Chaque objet est caractérisé par un ensemble de clefs qui représentent ses
3
attributs et des valeurs qui correspondent aux valeurs des attributs. Les collections sont une liste
d'objet. Sachant tout ça, le traitement devient simple.
//Pour traiter un object
JSONObject j = (JSONObject )JSONValue.parse(result.toString());
//valeur de la clef nom dans l'object JSON
String nom = (String)j.get("nom");
//valeur de la clef description
String description = (String)j.get("description");
}
Pour traiter une collection, il suffit d'itérer sur la collection et appliquer le traitement précédent sur
chaque objet trouvé
//Pour traiter une collection
JSONObject j = (JSONObject )JSONValue.parse(result.toString());
for(int i = 0 ; i< j.size(); i++)
{
JSONObject o = (JSONObject) j.get(i);
//valeur de la clef nom dans l'object JSON
String nom = (String)o.get("nom");
//valeur de la clef description
String description = (String)o.get("description");
System.out.println("For Object " + i + " we have :");
System.out.println("Nom " + nom);
System.out.println("Déscription " + description);
}
}
Il existe d'autres librairies JAVA bien plus avancées que celles qu'on a utilisée permettant de rendre le
traitement JSON plus dynamique et abstrait pour les developpeurs. Rappelez vous dans le TP 1 sur
lacréation des Web Services on n'a pas eu à traiter les formats JSON et XML dans la serialisation/
désérialisation des ressources. Ce travail a été fait automatiquement par JAXB et Jackson dans JERSEY.
Vous pouvez toujours utiliser ces librairies pour automatiser le traitement JSON/XML et rendre votre
code plus léger. Il y a aussi cette librairie de Google que j'utilise la plupart du temps pour traiter les
formats JSON, elle est ici.
• Faites une requête qui crée une nouvelle ressource sur le système
4
//Créez la requete
....
//Créez une représentation de l'objet en JSON
JSONObject obj = new JSONObject();
//Ajoutez les pairs clefs/valeurs
obj.put("nom", "Mathématiques");
obj.put("description", "Description des livres de maths");
//Construire une entité (au sens HTTP) avec l'objet
StringEntity entity = new StringEntity(obj.toJSONString());
request.setEntity(entity);
//Executez la requete
....
• Faites maintenant la mise à jour, la recherche par identifiant et la suppression d'une ressource
OPTIONNEL
Completez cette application en y ajoutant une interface permettant à un client de tester un service web
RESTFull. L'application doit présenter une interface offrant au client la possibilité :
1.
2.
3.
4.
D'entrer l'URI de la ressource,
De choisir le format de représentation de la ressource (envoie, reception)
De choisir le type d'opération à effectuer (Créer, Lire, Supprimer, Modifier,..)
De visualiser la réprésentation de la ressource
FIN
Récupéré depuis "http://miageprojet2.unice.fr/User:EdouardAmosse/
Consumer_les_web_services_RESTFull_en_JAVA/Client_Lourd_JAVA"
5