Réalisés par 

El Heni Nazih

Ezzair Mayssa

Elghoul Sinda

Mini projet : Service Web

2013-2014

Introduction

Un service   web  est   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).

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.

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 :

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

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 » 

package com.objis ;

import javax.jws.WebService;

import javax.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 le service :

« CalculWS .java »

package com.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;

}

}

3. Créer l’éditeur de service : « CalculPublisher.java »

package com.objis;

import javax.xml.ws.Endpoint;

public class CalculPublisher {

public static final String URI="http://localhost:8888/calcul";

public static void main(String[ ] args) {

CalculWS impl = 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 :

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 :

Résultat de l’exécution :

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 sont téléchargé vers WEB-INF/lib

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)

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. 

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>

<servlet-class>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 ».

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 :

package com.isamm.client;

import java.net.URI;

import javax.ws.rs.core.MediaType;

import javax.ws.rs.core.UriBuilder;

import com.sun.jersey.api.client.Client;

import com.sun.jersey.api.client.ClientResponse;

import com.sun.jersey.api.client.WebResource;

import com.sun.jersey.api.client.config.ClientConfig;

import com.sun.jersey.api.client.config.DefaultClientConfig;

public class TestClient {

public static void main(String[] args) {

ClientConfig config = new DefaultClientConfig();

Client client = Client.create(config);

WebResource service = client.resource(getBaseURI());

// Fluent interfaces

System.out.println(service.path("rest").path("calcul").accept(MediaType.TEXT_PLAIN).get(

ClientResponse.class).toString());

// Get plain text

//

System.out.println(service.path("rest").path("calcul").accept(MediaType.TEXT_PLAIN).get(

String.class));

// Get XML

System.out.println(service.path("rest").path("calcul").accept(MediaType.TEXT_XML).get(S

tring.class));

// The HTML

System.out.println(service.path("rest").path("calcul").accept(MediaType.TEXT_HTML).get(

String.class));

}

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 :

V. Problèmes résolue:

Aucune class Servlet n’a été spécifiée pour la Servlet Jersey reset service