1. Mini projet : Service Web
Réalisés par
El HeniNazih
Ezzair Mayssa
Elghoul Sinda
2013-2014

2. Introduction
Un service
webest
un
programme
informatique
de
la
famille
des technologies
web permettant la communication et l'échange de données entre applications et systèmes
hétérogènes dans des environnements distribués. Il s'agit donc d'un ensemble de
fonctionnalités exposées sur internet ou sur un intranet, par et pour des applications ou
machines, sans intervention humaine, de manière synchrone ou asynchrone. En effet, le
protocole de communication est défini dans le cadre de la norme SOAP dans la signature du
service exposé (WSDL).

3. I. Présentation
Un document WSDL se compose d'un ensemble d'éléments décrivant les types de données
utilisés par le service, les messages que le service peut recevoir, ainsi que les liaisons SOAP
associées à chaque message. Le schéma suivant illustre la structure du langage WSDL qui est
un document XML, en décrivant les relations entre les sections constituant un document
WSDL.
1. Structure de document WSDL :
 Contenu de fichier WSDL :
Un fichier WSDL contient donc sept éléments.





Types : fournit la définition de types de données utilisés pour décrire les messages
échangés.
Messages : représente une définition abstraire (noms et types) des données en cours
de transmission.
PortTypes : décrit un ensemble d'opérations. Chaque opération a zéro ou un
message en entrée, zéro ou plusieurs messages de sortie ou d'erreurs.
Binding : spécifie une liaison entre un <portType> et un protocole concret (SOAP,
HTTP...).
Service : indique les adresses de port de chaque liaison.

4. Port : représente un point d'accès de services défini par une adresse réseau et une
liaison.
 Opération : c'est la description d'une action exposée dans le port.

Le document WSDL peut être divisé en deux parties. Une partie pour les définitions
abstraites, tandis que la deuxième contient les descriptions concrètes.
2. SOAP (Simple Object Access Protocol)
Les interactions entre services Web s'effectuent par le biais d'envois de messages structurés
au format XML. Le protocole SOAP (Simple Object Access Protocol) fournit le cadre
permettant ces échanges.
II. Type de liaison SOAP vs type de liaison WSDL :
Il existe deux modèles de style de communication qui sont utilisés pour traduire une liaison à
un corps de message SOAP/ WSDL.
Ils sont :
 Document
 RPC
L'avantage d'utiliser un modèle de style du document est que vous pouvez structurer le
corps SOAP comme vous le voulez aussi que le contenu du corps du message SOAP est une
instance XML arbitraire.
Cependant, avec un modèle de style RPC, la structure du corps de la demande SOAP doit
contenir à la fois le nom de l'opération et l'ensemble des paramètres de la méthode. Le
modèle de type RPC assume une structure spécifique à l'instance XML contenus dans le
corps du message.
 RPC VS document :
 RPC :

5. Le corps d'un message SOAP de type RPC est construit d'une manière spécifique, qui est
défini dans la norme SOAP. Il est construit autour de l'hypothèse que vous souhaitez appeler
le service Web comme vous le feriez appeler une fonction normale ou une méthode qui fait
partie de votre code d'application. Le corps du message contient un élément XML pour
chaque "paramètre" de la méthode. Ces éléments de paramètre sont enveloppés dans un
élément XML qui contient le nom de la méthode qui est appelée. La réponse renvoie une
valeur unique (codé en XML), tout comme une méthode de programmation. Le code WSDL
pour un service Web de style RPC est moins complexe que celle d'un service Web le
document de style, mais ce n'est pas un gros problème car WSDL ne sont pas destinés à être
manipulés par les humains.
(-)Le principal inconvénient de style RPC est qu'il est étroitement couplé au code de
l'application. Cela signifie que si vous voulez changer l'ordre des Paramètres ou modifier les
types de ces paramètres, ce changement aura une incidence sur la définition du service Web
lui-même.
 Document:
Un service Web de style de document, ne contient pas de restrictions sur la façon dont le
corps SOAP doit être construit. Il vous permet d'inclure toutes les données XML que vous
voulez et aussi d'inclure un schéma pour cette XML.
(+)Le code WSDL pour un service Web style document est beaucoup plus complexe que celle
d'un service Web de style RPC, mais ce n'est pas un gros problème car WSDL ne sont pas
destinés à être manipulés par les humains.
(+)Services de style de document n'ont pas le problème d’un couplage fort, ils sont
faiblement couplés avec le code de l'application. (Par exemple, avec un service de style de
document, ce n'est pas grave si le programmeur décide d'utiliser un «float» au lieu d'un "int"
pour représenter un paramètre particulier, car il est tout converti en texte XML à la fin).

6. III. Service Web de Calcul : somme de deux valeurs :
a) Etapes de création de ce service web :
1. Créer interface de service web : Calcul.java
2. Créer le côté serveur implémentant le service :CalculWS .java
3. Créer l’éditeur de service : CalculPublisher.java
1. Créer interface de service web : « Calcul.java »
packagecom.objis ;
importjavax.jws.WebService;
importjavax.jws.soap.SOAPBinding;
@WebService
@SOAPBinding(style = SOAPBinding.Style.RPC)
public interface Calcul {
String calplus(int a, int b);
}
2. Créer
le
côté
serveur
implémentant
« CalculWS .java »
packagecom.objis ;
import javax.jws.WebService;
@WebService(endpointInterface = "com.objis.Calcul")
public class CalculWS implements Calcul {
@Override
public String calplus(int a, int b) {
int c = a+b;
return "le résulatat de l'operation plus est
}
"+c;
le
service :

7. }
3. Créer l’éditeur de service : « CalculPublisher.java »
packagecom.objis;
importjavax.xml.ws.Endpoint;
public class CalculPublisher {
public static final String URI="http://localhost:8888/calcul";
public static void main(String[ ] args) {
CalculWSimpl = new CalculWS();
Endpoint endpoint = Endpoint.publish(URI, impl);
boolean status = endpoint.isPublished();
System.out.println("ISAMM ING -->web service de calculplus est disponible
?"+status);} }
b) Lib :

8. c) Phase de Test :
 On
commence
l’exécution
du
programme
de
publication « CalculPublisher.java »
 L’URL lancé est :http://localhost:8888/calcul/
 On lance l’URL suivant http://localhost:8888/calcul?wsdl/ pour tester le service
web :

9.  Résultat de l’exécution :

10. IV. Version RESTful :
Réaliser la version RESTful
1. Installation :
 Jersey
2. Réalisation :
1. Créer nouveau projet : « RestfullCalcul »
2. Copier tout les lib de Jersey qui sonttéléchargé vers WEB-INF/lib

11. 3. Les Class Java :
 Class « Calcul.java » :
package com.isamm.res;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
// Plain old Java Object it does not extend as class or implements
// an interface
// The class registers its methods for the HTTP GET request using the @GET
annotation.
// Using the @Produces annotation, it defines that it can deliver several
MIME types,
// text, XML and HTML.
// The browser requests per default the HTML MIME type.
//Sets the path to base URL + /calcul
//http://localhost:8080/RestfullCalcul
@Path("/calcul")
public class Calcul {
int a= 5;
int b = 6 ;
// This method is called if TEXT_PLAIN is request
@GET
@Produces(MediaType.TEXT_PLAIN)

12. public String sayPlainTextHello() {
return ""+a+b;
}
// This method is called if XML is request
@GET
@Produces(MediaType.TEXT_XML)
public String sayXMLHello() {
int d= a+b ;
return "<?xml version="1.0"?>" + "<calcul> Nous les ingénieurs du web
ISAMM"+d+ "</calcul>";
}
// This method is called if HTML is request
@GET
@Produces(MediaType.TEXT_HTML)
public String sayHtmlHello() {
int d= a+b ;
return "<html> " + "<title>" + "Nous les ingénieurs du web ISAMM"
+"</title>"
+ "<body><h1>" + "le resulat du calcul est
:"+d+"</body></h1>"
+ "</html> ";
}
}
Cette classe elle-même s'inscrire comme une ressource Get via l'annotation @GET.
Via l'annotation @Produit elle définit ce qu’il délivre le texte et les types MIME HTML. Il
définit également par l’annotation @Path que son service est disponible sous Calcul l’URL.
4. Définirai« Jersey Servlet dispatcher »
On inscrire Jersey comme le régulateur de Servet pour les demandes REST.

13. On modifier le fichier web.xml :
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID"
version="3.0">
<display-name>RestfullCalcul</display-name>
<servlet>
<servlet-name>Jersey REST Service</servlet-name>
<servletclass>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>com.isamm.res</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Jersey REST Service</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
</web-app>
Le paramètre"com.sun.jersey.config.property.package" définie dans quel package jersey va
chercher les classes de service Web.
1. Exécuter le service :
On test le service par: "http://localhost:8080/de.vogella.jersey.first/rest/Calcul/". Ce nom
est dériver de "display-name" qui est définie dans le fichier « web.xml ».

14. 2. Créer le client :
Jersey contient une bibliothèque de client REST qui peut être utilisé pour l'essai ou de
construire un véritable client en Java. Alternative on peut utiliser Apache HttpClient pour
créer un client.
Créer un nouveau "de.vogella.jersey.first.client" Java et ajouter les jars de jersey pour le
projet et le chemin de génération de projet. Et on crée la class suivante :
packagecom.isamm.client;
importjava.net.URI;
importjavax.ws.rs.core.MediaType;
importjavax.ws.rs.core.UriBuilder;
import com.sun.jersey.api.client.Client;
importcom.sun.jersey.api.client.ClientResponse;
importcom.sun.jersey.api.client.WebResource;
importcom.sun.jersey.api.client.config.ClientConfig;
importcom.sun.jersey.api.client.config.DefaultClientConfig;
public class TestClient {
public static void main(String[] args) {
ClientConfigconfig = new DefaultClientConfig();
Client client = Client.create(config);
WebResource service = client.resource(getBaseURI());
// Fluent interfaces
System.out.println(service.path("rest").path("calcul").accept(MediaType.TEX
T_PLAIN).get(ClientResponse.class).toString());
// Get plain text
//
System.out.println(service.path("rest").path("calcul").accept(MediaType.TEX
T_PLAIN).get(String.class));
// Get XML
System.out.println(service.path("rest").path("calcul").accept(MediaType.TEX
T_XML).get(String.class));
// The HTML
System.out.println(service.path("rest").path("calcul").accept(MediaType.TEX
T_HTML).get(String.class));

15. }
private static URI getBaseURI() {
return UriBuilder.fromUri("http://localhost:8080/RestfullCalcul").build();
}
}
 On prend le service de calcul avec Get de protocole Http
3. Résultat de l’exécution :

16. V.
Problèmesrésolue:
 Aucune class Servlet n’a été spécifiée pour la Servlet Jersey reset service