Scribd
Importer
200 vues99 pages

Introduction aux Web Services SOAP et WSDL

Transféré par

Abdtouirsi nouhaila
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd
200 vues99 pages

Introduction aux Web Services SOAP et WSDL

Transféré par

Abdtouirsi nouhaila
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

Systèmes Distribués : Web Services : SOAP, WSDL, UDDI

SOAP, WSDL, UDDI : Concepts de base et Mise en œuvre

Mohamed Youssfi
Laboratoire Signaux Systèmes Distribués et Intelligence Artificielle (SSDIA)
ENSET, Université Hassan II Casablanca, Maroc
Email : med@[Link]
Supports de cours : [Link]
Chaîne vidéo : [Link]
Recherche : [Link]
Systèmes Distribués

Echange de données structurée, semi-structurée entre les Systèmes d’Information


Interopérabilité des Systèmes d’Information

Serveur d’application J2EE


Serveur d’application IIS

Application .net Application Java


XML

SGBD XML Parser XML Parser SGBD


SQL Server RMI, CORBA, Oracle
Web services,
[Link] [Link]
[Link]
GRPC
Structure d’un document XML

Un document XML se compose de 3 fichiers :

Document XML

Fichier XML DTD Feuille de style


Qui contient Ou XSL
Les données Schémas XML Pour la présentation
Pour déclarer Des données du
La structure Fichier XML
Du fichier XML

➢ Le fichier XML stocke les données du document sous forme d’un arbre
➢ DTD ( Data Type Definition ) ou Schémas XML définit la structure du fichier XML
➢ La feuille de style définit la mise en forme des données de la feuille xml
Introduction aux web services

Les Web Services sont des composants web basés sur Internet (HTTP ) qui exécutent des tâches
précises et qui respectent un format spécifique (XML).

Ils permettent aux applications de faire appel à des fonctionnalités à distance en simplifiant ainsi
l’échange de données.

Les Web Services permettent aux applications de dialoguer à travers le réseau, indépendamment de

• leur plate-forme d’exécution

• et de leur langage d'implémentation.

Ils s’inscrivent dans la continuité d'initiatives telles que

• CORBA (Common Object Request Broker Architecture, de l'OMG) en apportant toutefois une
réponse plus simple, s’appuyant sur des technologies et standards reconnus et maintenant
acceptés de tous.
Architecture de base des Web Services

Client Requête HTTP Serveur HTTP

PHP <?xml version="1.0" encoding="UTF-8"?> BanqueService


<Envelope>
.net <Header/> +conversion(double mt):double
<Body>
<conversion>
+Compte getCompte()
java <montant>12</montant> +List<Compte> getComptes()
</conversion>
</Body>
Cobol </Envelope> JaxWS Compte
-code : int
JaxB -solde: double
Réponse HTTP
<?xml version="1.0" encoding="UTF-8"?>
<Envelope>
<Body>
<conversionResponse>
<return>132</return>
</conversionResponse>
</Body>
</Envelope>
Requête SOAP avec POST

Entête de la requête

Post /WebServicePath HTTP/1.1


accept: application/xml
Content-Type : application/xml

*** saut de ligne ***

corps de la requête HTTP


Réponse SOAP : Entête de la réponse

HTTP/1.0 200 OK
Date : Wed, 05Feb02 [Link] GMT
Server : Apache/1.3.24
Mime-Version 1.0
Last-Modified : Wed 02Oct01 [Link]GMT
Content-Type : application/xml
Content-legnth : 4205
*** saut de ligne ***

corps de la réponse

med@[Link]
Concepts fondamentaux des web services

Le concept des Web Services s’articule actuellement autour des trois


concepts suivants :
• SOAP (Simple Object Access Protocol)
• est un protocole d'échange inter-applications indépendant de toute plate-forme, Serveur HTTP
basé sur le langage XML.
• Un appel de service SOAP est un flux ASCII encadré dans des balises XML et
transporté dans le protocole HTTP. UDDI

Discover

Register
• WSDL (Web Services Description Language)
• donne la description au format XML des Web Services en précisant les méthodes
pouvant être invoquées, leurs signatures et le point d’accès (URL, port, etc..).
• C’est, en quelque sorte, l’équivalent du langage IDL pour la programmation GET WSDL Serveur HTTP
distribuée CORBA. WSDL
Client Web
Service Invocation Web
• UDDI (Universal Description, Discovery and Integration) Service
• normalise une solution d’annuaire distribué de Web Services, permettant à la fois la SOAP = http+XML
publication et l'exploration (recherche) de Web Services.
• UDDI se comporte lui-même comme un Web service dont les méthodes sont
appelées via le protocole SOAP.
Mise en œuvre des
web services
avec JAX-WS
@WebService(serviceName="BanqueWS")

JAX-WS
public class BanqueService {
@WebMethod(operationName="ConversionEuroToDh")
public double conversion(@WebParam(name="montant")double mt){
return mt*11;
• JAX-WS est la nouvelle appellation de JAX- }
RPC (Java API for XML Based RPC) qui permet @WebMethod
public String test(){ return "Test"; }
de développer très simplement des services
@WebMethod
web en Java. public Compte getCompte(){ return new Compte (1,7000); }
• JAX-WS fournit un ensemble d'annotations @WebMethod
pour mapper la correspondance Java-WSDL. Il public List<Compte> getComptes(){
List<Compte> cptes=new ArrayList<Compte>();
suffit pour cela d'annoter directement les
[Link] (new Compte (1,7000)); return cptes;
classes Java qui vont représenter le service }}
web.
• Dans l'exemple ci-dessous, une classe Java
utilise des annotations JAX-WS qui vont
permettre par la suite de générer le
document WSDL. Le document WSDL est
auto-généré par le serveur d'application au
moment du déploiement :
Application
GET BanqueWS?wsdl
1. Créer un Web service qui permet de : Serveur JawWS 2
Web 3
WSDL
• Convertir un montant de l’auro en DH Browser
BanqueService 1
• Consulter un Compte 4
SoapUI WSDL, SOAP +conversion(double mt):double
• Consulter une Liste de comptes +Compte getCompte()
+List<Compte> getComptes()
2. Déployer le Web service avec un simple Serveur JaxWS Client Java 5 SOAP
Proxy Soap
3. Consulter et analyser le WSDL avec un Browser HTTP
JaxWS Compte
4. Tester les opérations du web service avec un outil Client .Net6 SOAP
-code : int
Proxy Soap JaxB -solde: double
comme SoapUI ou Oxygen

5. Créer un Client SOAP Java SOAP

6. Créer un Client SOAP Dot Net


Web Serveur Web Apache
7. Créer un Client SOAP PHP Browser http, HTML
PHP 7
8. Déployer le Web Service dans un Projet Spring Boot
Architecture 1 Client SOAP (Java, .Net, PHP)
Serveur JAXWS

BanqueService
Client +conversion(double mt):double
+Compte getCompte()
+List<Compte> getComptes()
1 6
2 3 4
STUB SOAP Compte
SKELETON
5 -code : int
-solde: double

1 Le client demande au stub de faire appel à la méthode conversion(12)


Client Serveur
2 Le Stub se connecte au Skeleton et lui envoie une requête SOAP
Client WS STUB SKELETON Web Service
3 Le Skeleton fait appel à la méthode du web service
Conversion (11)
Requête SOAP
4 Le web service retourne le résultat au Skeleton Conversion(11)
SOAP = http+XML Return 121
5 Le Skeleton envoie le résultat dans une la réponse SOAP au Stub
Return 121
Réponse SOAP
Le Stub fournie lé résultat au client
6
Application
GET BanqueWS?wsdl
1. Créer un Web service qui permet de : Serveur JawWS 2
Web 3
WSDL
• Convertir un montant de l’auro en DH Browser
BanqueService 1
• Consulter un Compte 4
SoapUI WSDL, SOAP +conversion(double mt):double
• Consulter une Liste de comptes +Compte getCompte()
+List<Compte> getComptes()
2. Déployer le Web service avec un simple Serveur JaxWS Client Java 5 SOAP
Proxy Soap
3. Consulter et analyser le WSDL avec un Browser HTTP
JaxWS Compte
4. Tester les opérations du web service avec un outil Client .Net6 SOAP
-code : int
Proxy Soap JaxB -solde: double
comme SoapUI ou Oxygen

5. Créer un Client SOAP Java SOAP

6. Créer un Client SOAP Dot Net


Web Serveur Web Apache
7. Créer un Client SOAP PHP Browser http, HTML
PHP 7
8. Déployer le Web Service dans un Projet Spring Boot
Mapping Objet XML (OXM)
Avec Jax Binding (JaxB2)
JAX-WS / JAXB

▸JAX-WS s'appuie sur l'API JAXB 2.0 pour


tout ce qui concerne la correspondance
entre document XML et objets Java.

▸JAXB 2.0 permet de mapper des


objets Java dans un document
XML et vice versa.
▸Il permet aussi de générer des
classes Java à partir un schéma
XML et vice et versa.
Principe de JAXB

▸Le mapping d'un document XML à des objets (unmarshal)

▸La création d'un document XML à partir d'objets (marshal)


Générer XML à partir des objet java avec JAXB

package ws;
import [Link];
import [Link].*;
@XmlRootElement package ws;
import [Link]; import [Link];
public class Compte {
import [Link].*;
private int code; public class Banque {
public static void main(String[] args) throws Exception {
private float solde;
JAXBContext context=[Link]([Link]);
private Date dateCreation; Marshaller marshaller=[Link]();
[Link](Marshaller.JAXB_FORMATTED_OUTPUT,true);
// Constructeur sans paramètre
Compte cp=new Compte(1,8000,new Date());
// Constructeur avec paramètres [Link](cp,new File("[Link]"));
}}
// Getters et Setters
}

<?xml version="1.0" encoding="UTF-8"?>


<compte>
<code>1</code>
<dateCreation>
Fichier XML Généré : [Link]
2014-01-16T[Link].960Z
</dateCreation>
<solde>8000.0</solde>
</compte>
Générer des objets java à partir des données XML

package ws;
import [Link].*;
import [Link].*;
public class Banque2 {
public static void main(String[] args) throws Exception {
JAXBContext jc=[Link]([Link]);
Unmarshaller unmarshaller=[Link]();
Compte cp=(Compte) [Link](new File("[Link]"));
[Link]([Link]()+"-"+[Link]()+"-"+[Link]());
}
}

Fichier XML Source : [Link]


<?xml version="1.0" encoding="UTF-
8"?>
<compte>
<code>1</code>
<dateCreation>
2014-01-16T[Link].960Z
</dateCreation>
<solde>8000.0</solde>
</compte>
Générer un schéma XML à partir d’une classe avec JaxB
package ws;
import [Link];
package ws; import [Link].*;
import [Link].*; @XmlRootElement
import [Link].*;import [Link];
public class Compte {
import [Link];
public class Banque { private int code;
public static void main(String[] args) throws Exception { private float solde;
JAXBContext context=[Link]([Link]);
private Date dateCreation;
[Link](new SchemaOutputResolver() {
@Override // Constructeur sans paramètre
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException
// Constructeur { paramètres
avec
File f=new File("[Link]");
StreamResult result=new StreamResult(f); // Getters et Setters
[Link]([Link]()); }
return result;
} <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
});}} <xs:schema version="1.0" xmlns:xs="[Link]
<xs:element name="compte" type="compte"/>
<xs:complexType name="compte">
<xs:sequence>
<xs:element name="code" type="xs:int"/>
<xs:element name="dateCreation" type="xs:dateTime" minOccurs="0"/>
<xs:element name="solde" type="xs:float"/>
</xs:sequence>
</xs:complexType>
</xs:schema>
Génération des classes à partir d’un schéma XML avec XJC

▸ Pour permettre l'utilisation et la manipulation d'un document XML, JAXB propose de générer un ensemble de classes à partir du schéma
XML du document.

▸L'implémentation de référence fournit l'outil xjc pour générer les


classes à partir d'un schéma XML.

▸L'utilisation la plus simple de l'outil xjc est de lui fournir simplement le


fichier qui contient le schéma XML du document à utiliser.
Classes générées par XJC par XJC

▸ L’outil XJC génère deux classes :

• [Link] qui correspond au type complexe Compte dans le schéma xml.

• [Link] : une fabrique qui permet de créer des objets de type Compte.
Quelques annotations JAXB

Annotation Description
Associer une classe ou une énumération à
@XmlRootElement
un élément XML
Associer un espace de nommage à un
@XmlSchema
package
Marquer une entité pour ne pas être
@XmlTransient
mappée dans le document XML
Convertir une propriété en un attribut
@XmlAttribute
dans le document XML
Convertir une propriété en un élément
@XmlElement
dans le document XML
Préciser comment un champ ou une
@XmlAccessorType
propriété est sérialisé
Associer un prefixe d'un espace de
@XmlNs
nommage à un URI
Implémentation du Web Service JaxWS
package ws; package metier;
import [Link].*; import [Link];
import [Link].*; import [Link];
import [Link]; import [Link];
@WebService(serviceName="BanqueWS") @XmlRootElement
public class BanqueService { @XmlAccessorType([Link])
@WebMethod(operationName="ConversionEuroToDh") public class Compte {
public double conversion(@WebParam(name="montant")double mt){ private Long code;
return mt*11; private double solde;
} @XmlTransient
@WebMethod private Date dateCreation;
public Compte getCompte(@WebParam(name="code")Long code){ // Constructeurs
return new Compte (code,7000,new Date()); // Getters et setters
} }
@WebMethod
public List<Compte> getComptes(){
List<Compte> cptes=new ArrayList<Compte>();
[Link] (new Compte (1L,7000,new Date()));
[Link] (new Compte (2L,7000,new Date()));
return cptes;
}}
Simple Serveur JAX WS

import [Link];
import [Link];
public class ServeurJWS {
public static void main(String[] args) {
String url="[Link]
[Link](url, new BanqueService());
[Link](url);
}
}

Exécution du serveur Java

med@[Link]
Analyser le WSDL
Pour Visualiser le WSDL, vous pouvez utiliser un navigateur web

med@[Link]
Déployer un Web service dans un projet Spring Boot

Web Service
@Component
@WebService
public class BanqueService {
// Opérations du web service
}

Classe de configuration
@Configuration
public class MyConfig {
@Bean
public SimpleJaxWsServiceExporter getJWS() {
SimpleJaxWsServiceExporter exporter=new SimpleJaxWsServiceExporter();
[Link]("[Link]
return exporter;
}
}
Structure du WSDL

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.
Structure du 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.

med@[Link]
Structure du WSDL
Elément Types

med@[Link]
XML Schema
XML Schema
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:tns="[Link] xmlns:xs="[Link] version="1.0"
targetNamespace="[Link]
<xs:element name="ConversionEuroToDh" type="tns:ConversionEuroToDh"></xs:element>
<xs:element name="ConversionEuroToDhResponse" type="tns:ConversionEuroToDhResponse"/>
<xs:element name="compte" type="tns:compte"></xs:element>
<xs:element name="getCompte" type="tns:getCompte"></xs:element>
<xs:element name="getCompteResponse" type="tns:getCompteResponse"></xs:element>
<xs:element name="getComptes" type="tns:getComptes"></xs:element>
<xs:element name="getComptesResponse" type="tns:getComptesResponse"></xs:element>
<xs:complexType name="ConversionEuroToDh">
<xs:sequence>
<xs:element name="montant" type="xs:double"></xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="ConversionEuroToDhResponse">
<xs:sequence>
<xs:element name="return" type="xs:double"></xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="getCompte">
XML Schema <xs:sequence>
<xs:element name="code" type="xs:long" minOccurs="0"></xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="getCompteResponse">
<xs:sequence>
<xs:element name="return" type="tns:compte" minOccurs="0"></xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="compte">
<xs:sequence>
<xs:element name="code" type="xs:long" minOccurs="0"></xs:element>
<xs:element name="solde" type="xs:double"></xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="getComptes">
<xs:sequence></xs:sequence>
</xs:complexType>
<xs:complexType name="getComptesResponse">
<xs:sequence>
<xs:element name="return" type="tns:compte" minOccurs="0" maxOccurs="unbounded"></xs:element>
</xs:sequence>
</xs:complexType>
</xs:schema>
Elément message

<message name="getCompte">
<part name="parameters" element="tns:getCompte"></part>
</message>
<message name="getCompteResponse">
<part name="parameters" element="tns:getCompteResponse"></part>
</message>
med@[Link]
Elément portType

<portType name="BanqueService">
<operation name="getCompte">
<input wsam:Action="[Link] message="tns:getCompte"></input>
<output wsam:Action="[Link]
message="tns:getCompteResponse"></output>
</operation>
<operation name="getComptes">
<input wsam:Action="[Link] message="tns:getComptes"></input>
<output wsam:Action="[Link]
message="tns:getComptesResponse"></output>
</operation>
<operation name="ConversionEuroToDh">
…..
</operation>
</portType>
med@[Link]
Elément binding

<binding name="BanqueServicePortBinding" type="tns:BanqueService">


<soap:binding transport="[Link] style="document"></soap:binding>
<operation name="getCompte">
<soap:operation soapAction=""></soap:operation>
<input>
<soap:body use="literal"></soap:body>
</input>
<output>
<soap:body use="literal"></soap:body>
</output>
</operation>
<operation name="getComptes">
…..
</operation>
</binding>
Elément service

<service name="BanqueWS">
<port name="BanqueServicePort"
binding="tns:BanqueServicePortBinding">
<soap:address location="[Link]
</port>
</service>

med@[Link]
Tester les méthodes du web service avec un
analyseur SOAP : SoapUI
Tester les méthodes du web service avec un
analyseur SOAP : SoapUI

med@[Link]
Tester la méthode conversion

Requête SOAP
<soapenv:Envelope xmlns:soapenv="[Link] xmlns:ws="[Link]
<soapenv:Header/>
<soapenv:Body>
<ws:ConversionEuroToDh>
<montant>60</montant>
</ws:ConversionEuroToDh>
</soapenv:Body>
</soapenv:Envelope>

Réponse SOAP
 <S:Envelope xmlns:S="[Link]
<S:Body>
<ns2:ConversionEuroToDhResponse xmlns:ns2="[Link]
<return>660.0</return>
</ns2:ConversionEuroToDhResponse>
</S:Body>
</S:Envelope>
med@[Link]
Tester la méthode getCompte
Requête SOAP
<soapenv:Envelope xmlns:soapenv="[Link] xmlns:ws="[Link]
<soapenv:Header/>
<soapenv:Body>
<ws:getCompte>
<code>2</code>
</ws:getCompte>
</soapenv:Body>
</soapenv:Envelope>

Réponse SOAP
 <S:Envelope xmlns:S="[Link]
<S:Body>
<ns2:getCompteResponse xmlns:ns2="[Link]
<return>
<code>2</code>
<solde>7000.0</solde>
</return>
</ns2:getCompteResponse>
</S:Body>
</S:Envelope>
med@[Link]
Tester la méthode getComptes
Requête SOAP
<soapenv:Envelope xmlns:soapenv="[Link] xmlns:ws="[Link]
<soapenv:Header/>
<soapenv:Body>
<ws:getComptes/>
</soapenv:Body>
</soapenv:Envelope>

Réponse SOAP
 <S:Envelope xmlns:S="[Link]
<S:Body>
<ns2:getComptesResponse xmlns:ns2="[Link]
<return>
<code>1</code>
<solde>7000.0</solde>
</return>
<return>
<code>2</code>
<solde>7000.0</solde>
</return>
</ns2:getComptesResponse>
</S:Body>
</S:Envelope> med@[Link]
Client Java

Créer un nouveau projet Java


Générer un proxy
• SoapUI est l’un des outils qui peuvent être utilisés pour générer les artefacts
client en utilisant différents Framework (Axis, CXF, JaxWS, etc…)
• Le JDK fournit une commande simple qui permet de générer un STUB JaxWS
pour l’accès à un web service. Cette commande s’appelle wsimport.
• SoapUI a besoin de savoir le chemin de cette commande
• Avec la commande File >Preferences>Tools , vous pouvez configurer le ce
chemin comme le montre la figure suivante :
Préférence générale de SoapUI

med@[Link]
Générer le STUB JaxWS

med@[Link]
Fichiers Générés

med@[Link]
Client Java Serveur

import [Link]; Web Service


import [Link];
import [Link];
import [Link];
public class ClientWS { Skeleton
public static void main(String[] args) {

BanqueService stub=new BanqueWS().getBanqueServicePort();


[Link]("Conversion"); SOAP
[Link]([Link](9000));
Stub
[Link]("Consulter un compte");
Compte cp=[Link](2L); Client Java
[Link]("Solde="+[Link]());
[Link]("Liste des comptes");
List<Compte> cptes=[Link]();
for(Compte c:cptes){
[Link]([Link]()+"----"+[Link]());
}
}
}

med@[Link]
Architecture
Client SOAP Serveur JAXWS

BanqueService
Client +conversion(double mt):double
+test():String

1 6 3 4
2
STUB SOAP SKELETON

5
1 Le client demande au stub de faire appel à la méthode conversion(12)

2 Le Stub se connecte au Skeleton et lui envoie une requête SOAP

3 Le Skeleton fait appel à la méthode du web service


4 Le web service retourne le résultat au Skeleton
5 Le Skeleton envoie le résultat dans une la réponse SOAP au Stub
med@[Link]
6 Le Stub fournie lé résultat au client
Client JSP
Serveur JAXWS

BanqueService
Web Container : Tomcat +conversion(double mt):double
+getCompte(int code):Compte
+getComptes():List<Compte>

[Link] 3 4
2
SOAP SKELETON
5

1 HTTP 6

Client HTTP

med@[Link]
Création d’un projet Web Dynamique basé sur Tomcat 7

Créer un projet Web Dynamique basé sur Tomcat 7

med@[Link]
Projet Web Dynamique

med@[Link]
Générer un proxy (Stub) pour le web Service
Fichier > Nouveau > Web Service Client
Génération du proxy
Générer le proxy à partir du WSDL
Fichier Générés

Le proxy généré est basé sur AXIS


Client JSP

<%@page import="[Link]"%>
<%
double montant=0; double resultat=0;
if([Link]("montant")!=null){
montant=[Link]([Link]("montant"));
BanqueServiceProxy service=new BanqueServiceProxy();
resultat=[Link](montant);
}
%>
<html><body>
<form action="[Link]">
Montant :<input type="text" name="montant" value="<%=montant%>">
<input type="submit" value="OK">
</form>
<%=montant %> en Euro est égale à <%=resultat %> en DH
</body></html>
Client SOAP avec .Net

En utilisant Visual Studio (2010), Créer un projet C# de type Console

med@[Link]
Générer Le Proxy client Soap
Code C# du client

Serveur
using System;
namespace ClientSOAP
{ Web Service
class Program
{
static void Main(string[] args)
{ Skeleton
[Link] stub =
new [Link]();
[Link]("-------- Conversion ---------");
[Link]([Link](34));
SOAP
[Link]("-------- Consulter un Compte ---------");
[Link] cp = [Link](2L); Stub
[Link]("Solde=" + [Link]);
[Link]("-------- Liste des comptes ---------");
[Link][] cptes = [Link](); Client .Net
for (int i = 0; i < [Link]; i++)
{
[Link](cptes[i].code + "-----" + cptes[i].solde);
}
[Link]();
}
}
}

med@[Link]
Dessiner les composants graphique de l’interface

Serveur

Web Service

Skeleton

SOAP

Stub

Client .Net
Web Service Java et Client PHP
Serveur JAXWS

BanqueService
Serveur Web Apache +conversion(double mt):double
+getCompte(int code):Compte
+getComptes():List<Compte>

[Link] 3 4
2
SOAP SKELETON
5

1 HTTP 6

Client HTTP

med@[Link]
Exemple de Client SOAP PHP

<?php
$client = new SoapClient('[Link]
$param=new stdClass();
$param->montant=23;
$res=$client->__soapCall("conversionEuroDH",array($param));
//var_dump($res);
echo($res->return);
$param2=new stdClass();
$param2->arg0=2;
$res2=$client->__soapCall("getCompte",array($param2));
//var_dump($res2);
echo("Code=".$res2->return->code);
echo("<br/>Solde=".$res2->return->solde);
$res3=$client->__soapCall("getComptes",array());
//var_dump($res3);
echo ("<hr/>");
foreach($res3->return as $cpte){
echo("Code=".$cpte->code);
echo("<br/>Solde=".$cpte->solde);
echo("<br/>");
}
?>
Code PHP
<?php
$montant=0;$resultat=0;
if (isset($_GET['montant'])){
$montant=$_GET['montant'];
$client = new SoapClient('[Link]
$param=new stdClass();
$param->montant=$montant;
$rep=$client->__soapCall("conversionEuroDH",array($param));
$resultat=$rep->return;
}
?>
<html>
<body>
<form action="[Link]">
Montant :<input type="text" name="montant" value="<?php echo($montant)?>">
<input type="submit" value="OK">
</form>
<?php echo($montant)?> en Euro est égale à <?php echo($resultat)?> en DH
</body>
</html>
Un autre exemple Client SOAP PHP

<?php
$mt=0;
if(isset($_POST['action'])){
$action=$_POST['action'];
if($action=="OK"){
$mt=$_POST['montant'];
$client=new SoapClient("[Link]
$param=new stdClass();
$param->montant=$mt;
$rep=$client->__soapCall("conversionEuroToDh",array($param));
$res=$rep->return;
}
elseif($action=="listComptes"){
$client=new SoapClient("[Link]
$res2=$client->__soapCall("getComptes",array());
}
}

?>
Suite de l’exemple du Client SOAP PHP
<html>
<body>
<form method="post" action="[Link]">
Montant:<input type="text" name="montant" value="<?php echo($mt)?>">
<input type="submit" value="OK" name="action">
<input type="submit" value="listComptes" name="action">
</form>

Rsultat:
<?php if (isset($res)){
echo($res);
}
?>
<?php if(isset($res2)){?>
<table border="1" width="80%">
<tr>
<th>CODE</th><th>SOLDE</th>
</tr>
<?php foreach($res2->return as $cp) {?>
<tr>
<td><?php echo($cp->code)?></td>
<td><?php echo($cp->solde)?></td>
</tr>
<?php }?>
</table>
<?php }?>
</body>
</html>
med@[Link]
UDDI

• L'annuaire des services UDDI est un standard pour la publication et la découverte des
informations sur les services Web.

• La spécification UDDI est une initiative lancée par ARIBA, Microsoft et IBM.

• Cette spécification n'est pas gérée par le W3C mais par le groupe OASIS.

• La spécification UDDI vise à créer une plate-forme indépendante, un espace de travail


(framework) ouvert pour la description, la découverte et l'intégration des services des
entreprises.
Consultation de l'annuaire

L'annuaire UDDI se concentre sur le processus de découverte de


l'architecture orientée services (SOA), et utilise des technologies
standards telles que XML, SOAP et WSDL qui permettent de simplifier la
collaboration entre partenaires dans le cadre des échanges
commerciaux.
L'accès au référentiel s'effectue de différentes manières.
• Les pages blanches : comprennent la liste des entreprises ainsi que
des informations associées à ces dernières (coordonnées, description
de l'entreprise, identifiants...).
• Les pages jaunes : recensent les services Web de chacune des
entreprises sous le standard WSDL.
• Les pages vertes : fournissent des informations techniques précises
sur les services fournis.
Architecture

Les entreprises publient les descriptions de leurs services Web en UDDI, sous la forme de fichiers
WSDL.
Ainsi, les clients peuvent plus facilement rechercher les services Web dont ils ont besoin en
interrogeant le registre UDDI.
Lorsqu'un client trouve une description de service Web qui lui convient, il télécharge son fichier
WSDL depuis le registre UDDI. Ensuite, à partir des informations inscrites dans le fichier WSDL,
notamment la référence vers le service Web, le client peut invoquer le service Web et lui demande
d'exécuter certaines de ses fonctionnalités.
Le scénario classique d'utilisation de UDDI est illustré ci-dessous. L'entreprise B a publié le service
Web S, et l'entreprise A est client de ce service :

Entreprse A UDDI Entreprse B

Publication du Web Service


Découverte du Web Service
SOAP

SOAP
Structures de données UDDI

Un registre UDDI se
compose de quatre types
de structures de données,
• le businessEntity,
• Le businessService,
• le bindingTemplate
• et la tModel.

med@[Link]
BusinessEntity (entité d'affaires)

Les « businessEntities » sont en quelque sorte les pages blanches d'un annuaire UDDI.
Elles décrivent les organisations ayant publié des services dans le répertoire.
On y trouve notamment
• le nom de l'organisation,
• ses adresses (physiques et Web),
• des éléments de classification,
• une liste de contacts
• ainsi que d'autres informations.
BusinessService (service d'affaires)

Les « businessServices » sont en quelque sorte les pages jaunes d'un annuaire
UDDI.
Elles décrivent de manière non technique les services proposés par les différentes
organisations.
On y trouve essentiellement
• le nom et la description textuelle des services
• ainsi qu'une référence à l'organisation proposant le service
• et un ou plusieurs « bindingTemplate ».

med@[Link]
BindingTemplate (modèle de rattachement)

• UDDI permet de décrire des services Web utilisant HTTP, mais également des services invoqués par
d'autres moyens (SMTP, FTP...).

• Les « bindingTemplates » donnent les coordonnées des services.

• Ce sont les pages vertes de l'annuaire UDDI.

• Ils contiennent notamment une description, la définition du point d'accès (une URL) et les éventuels «
tModels » associés.
tModel (index)

• Les « tModels » sont les descriptions techniques des services.

• UDDI n'impose aucun format pour ces descriptions qui peuvent être publiées
sous n'importe quelle forme et notamment sous forme de documents textuels
(XHTML, par exemple).

• C'est à ce niveau que WSDL intervient comme le vocabulaire de choix pour


publier des descriptions techniques de services.

med@[Link]
L'interface UDDI

L'interface UDDI est définie sous forme de documents UDDI et implémentée sous forme de service Web
SOAP.

Elle est composée des modules suivants :

• Interrogation inquiry : Cette interface permet de rechercher des informations dans un répertoire UDDI.

• Publication : Cette interface permet de publier des informations dans un répertoire UDDI.

• Sécurité : cette interface est utilisée pour obtenir et révoquer les jetons d'authentification nécessaires
pour accéder aux enregistrements protégés dans un annuaire UDDI.

• Contrôle d'accès et propriété custody and ownership transfer: Cette interface permet de transférer la
propriété d'informations (qui est à l'origine attribuée à l'utilisateur ayant publié ces informations) et de
gérer les droits d'accès associés.

• Abonnement Subscription : Cette interface permet à un client de s'abonner à un ensemble


d'informations et d'être averti lors des modifications de ces informations.
Systèmes Distribués : Web Services : RESTful
RESTful avec JAXRS, RestController, Spring Data Rest

Mohamed Youssfi
Laboratoire Signaux Systèmes Distribués et Intelligence Artificielle (SSDIA)
ENSET, Université Hassan II Casablanca, Maroc
Email : med@[Link]
Supports de cours : [Link]
Chaîne vidéo : [Link]
Recherche : [Link]
Problème des Web services SOAP

Client Requête HTTP Serveur HTTP

PHP <?xml version="1.0" encoding="UTF-8"?> BanqueService


<Envelope>
.net <Header/> +conversion(double mt):double
<Body>
<conversion>
+Compte getCompte()
java <montant>12</montant> +List<Compte> getComptes()
</conversion>
</Body>
Cobol </Envelope> JaxWS Compte
-code : int
JaxB -solde: double
Réponse HTTP
<?xml version="1.0" encoding="UTF-8"?>
<Envelope>
<Body>
<conversionResponse>
<return>132</return>
</conversionResponse>
</Body>
</Envelope>
RESTful

• REST (REpresentational State Transfer)


ou RESTful est un style d’architecture pour
les systèmes hypermédia distribués, WADL (Web Application Description Language)
Equivalent à WSDL pour SOAP
• Créé par Roy Fielding en 2000 dans le
chapitre 5 de sa thèse de doctorat.
Client Web Container : Tomcat
• REST est un style d’architecture permettant HTTP, HTML
Leger
de construire des applications (Web,
Intranet, Web Service). Client Jersey JAXRS
HTTP, XML
Java Servlet
• Il s’agit d’un ensemble de conventions et
de bonnes pratiques à respecter et non Client
HTTP, JSON
d’une technologie à part entière. .net Web Service

• L’architecture REST utilise les spécifications Client Methode1()


HTTP, JSON
originelles du protocole HTTP, plutôt que Mobile Methode2()
de réinventer une surcouche (comme le
font SOAP ou XML-RPC par exemple).
Les 5 Règles de RESTful
• REST se base sur les URI (Uniform Resource Identifier) afin
• Règle n°1 : d’identifier une ressource.
• l’URI comme identifiant des ressources :
• Ainsi une application se doit de construire ses URI (et donc ses URL) de
• Respecter un standard pour construire les URLs manière précise, en tenant compte des contraintes REST.
• Règle n°2 : • Il est nécessaire de prendre en compte la hiérarchie des ressources et
• les méthode HTTP comme identifiant des opérations: la sémantique des URL pour les éditer :
POST : Pour Ajouter (Create)
•
• Liste des livres
• GET : pour consulter (Read)
• GET [Link]
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
• DELETE : pour supprimer (DELETE) • Filtre et tri sur les livres
• Règle n°3 : • GET [Link]
• les réponses HTTP comme représentation des ressources • Consulter un livre
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client • GET [Link]
• Règle n°4 :
• Tous les commentaires sur un livre
• les liens comme relation entre ressources
• GET [Link]
• <a href="..." rel="payment" >Effectuer un payement</a>
• Ajoute un livre
• Règle n°5 :
• Un paramètre comme jeton d’authentification : • POST [Link]
• Envoyer un jeton d’authentification différent pour chaque requête • Mettre à ajour un livre
• PUT [Link]
• Supprimer un livre
• DELETE [Link]
Les 5 Règles de RESTful

• Règle n°1 : • La seconde règle d’une architecture REST est


• l’URI comme identifiant des ressources : d’utiliser les verbes HTTP existants plutôt que
• Respecter un standard pour construire les URLs
d’inclure l’opération dans l’URI de la ressource.
• Règle n°2 :
• les méthode HTTP comme identifiant des opérations: • Ainsi, généralement pour une ressource, il y a 4
• POST : Pour Ajouter (Create)
opérations possibles (CRUD) :
• GET : pour consulter (Read)
• PUT : pour mise à jour (Update) ou PATCH pour update partiel • Créer (create)
DELETE : pour supprimer (DELETE)
•
• Afficher (read)
• Règle n°3 :
• les réponses HTTP comme représentation des ressources • Mettre à jour (update)
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du
client
• Supprimer (delete)
• Règle n°4 :
• HTTP propose les verbes correspondant :
• les liens comme relation entre ressources
• <a href="..." rel="payment" >Effectuer un payement</a> • Créer (create) => POST
• Règle n°5 :
• Un paramètre comme jeton d’authentification :
• Afficher (read) => GET
• Envoyer un jeton d’authentification différent pour chaque requête • Mettre à jour (update) => PUT ou PATCH
• Supprimer (delete) => DELETE
Les 5 Règles de RESTful

• Règle n°1 : • Il est important d’avoir à l’esprit que la


• l’URI comme identifiant des ressources : réponse envoyée n’est pas une ressource,
• Respecter un standard pour construire les URLs
mais plutôt la représentation d’une ressource.
• Règle n°2 :
• les méthode HTTP comme identifiant des opérations: • Ainsi, une ressource peut avoir plusieurs
• POST : Pour Ajouter (Create) représentations dans des formats divers
• GET : pour consulter (Read)
: HTML, XML, CSV, JSON, etc.
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
• DELETE : pour supprimer (DELETE) • C’est au client de définir quel format de
• Règle n°3 : réponse il souhaite reçevoir via l’entête http
• les réponses HTTP comme représentation des ressources
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client
Accept.
• Règle n°4 : • Il est possible de définir plusieurs formats.
les liens comme relation entre ressources
•
• Demander une réponse en HTML
• <a href="..." rel="payment" >Effectuer un payement</a>
• GET /books
• Règle n°5 :
Host: [Link]
• Un paramètre comme jeton d’authentification : Accept: application/xml
• Envoyer un jeton d’authentification différent pour chaque requête
• Demander une réponse en XML
• GET /books
Host: [Link]
Accept: application/json
Les 5 Règles de RESTful

• Règle n°1 : • Les liens d’une ressource vers une autre


• l’URI comme identifiant des ressources : indiquent la présence d’une relation.
• Respecter un standard pour construire les URLs

• Règle n°2 : • Il est cependant possible de la décrire afin


• les méthode HTTP comme identifiant des opérations: d’améliorer la compréhension du système.
• POST : Pour Ajouter (Create)
• GET : pour consulter (Read) • Exemple quand on consule une ressource qui
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
représente un produit d’une catégorie, on
• DELETE : pour supprimer (DELETE)

• Règle n°3 : trouve dans la description du produit un lien


• les réponses HTTP comme représentation des ressources significatif qui permet de consulter la
catégorie de ce produit
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client

• Règle n°4 :
• les liens comme relation entre ressources • Ainsi l’IANA donne une liste de relation parmi
• <a href="..." rel="payment" >Effectuer un payement</a>
lesquelles :
• Règle n°5 :
• Un paramètre comme jeton d’authentification : • Contents, edit, next, last, payment, etc.
• Envoyer un jeton d’authentification différent pour chaque requête
• La liste complète sur le site de l’IANA :
• [Link]
relations/[Link]
Les 5 Règles de RESTful

• Règle n°1 :
• C’est un des sujets les plus souvent abordé
l’URI comme identifiant des ressources :
quand on parle de REST : comment
•
• Respecter un standard pour construire les URLs
authentifier une requête ?
• Règle n°2 :
les méthode HTTP comme identifiant des opérations:
• Pour authentifier les requêtes HTTP, il faut
envoyer dans la requête un jeton
•
POST : Pour Ajouter (Create)
d’authentification de la requête
•
• GET : pour consulter (Read)
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
• DELETE : pour supprimer (DELETE) • Le premier Jeton X est obtenu au moment de
• Règle n°3 : l’authentification.
• les réponses HTTP comme représentation des ressources
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client • Pour chaque requête HTTP, ce jeton X peut
• Règle n°4 : être mélangé avec l’URL de la requête en
• les liens comme relation entre ressources utilisant une opération de hachage.
• <a href="..." rel="payment" >Effectuer un payement</a>

• Règle n°5 : • Cette opération permet d’avoir un jeton


• Un paramètre comme jeton d’authentification : différent pour chaque requête
• Envoyer un jeton d’authentification différent pour chaque requête

• Exemple de Token d’authentification : JWT


(Json Web Token)
Spécification JEE : JAX-RS pour RESTFUL

• JAX-RS est l’acronyme Java API for RESTful Web Services


• Décrite par la JSR 311 ([Link]/en/jsr/summary?id=311) << API >>
• Version courante de la spécification est la 1.1 JAX-RS
• Depuis la version 1.1, JAX-RS fait partie intégrante de la
spécification Java EE 6 au niveau de la pile Service Web
• Cette spécification décrit uniquement la mise en œuvre Application
de services Web REST coté serveur
• Le développements des Services Web REST repose sur
Jersey CXF REstEasy
l’utilisation de classes Java et d’annotations Référence
• Différentes implémentations de la spécification JAX-RS
sont disponibles
<< API >>
• JERSEY : implémentation de référence fournie par Oracle
Site projet : [Link] JAX-WS
• CXF : fournie par Apache, la fusion entre XFire et Celtix
Site projet : [Link]

• RESTEasy : fournie par JBoss Site projet : Application


[Link]/resteasy

• RESTlet : un des premiers framework implémentant REST JaxWSImpl CXF AXIS2


pour Java : Site projet : [Link]
Référence
Format JSON Vs XML

// x est un objet java script


• JSON (JavaScript Object Notation – Notation Objet issue de JavaScript) est var x={a:4,b:9};
un format léger d'échange de données. // T1 est un tableau java script
var T1=[8,6,8];
• Il est facile à lire ou à écrire pour des humains. Il est aisément analysable // T2 est un tableau d'objets
ou générable par des machines. var T2=[{a:2,b:6},{a:1,b:8},{a:2,b:4}];

• JSON est un format texte complètement indépendant de tout langage, XML


mais les conventions qu'il utilise seront familières à tout programmeur <?xml version="1.0" encoding="UTF-8"?>
<comptes>
habitué aux langages descendant du C, comme par exemple : C lui-même, <compte type="courant">
C++, C#, Java, JavaScript, Perl, Python et bien d'autres. <code>1</code>
<solde>4300</solde>
<dateCreation>2012-11-11</dateCreation>
</compte>
• Ces propriétés font de JSON un langage d'échange de données idéal. <compte type="epargne">
<code>2</code>
<solde>96000</solde>
<dateCreation>2012-12-11</dateCreation>
</compte>
</comptes>
JSON
[
{"type":"courant" , "code":1, "solde":4300,"dateCreation":1596711188451},
{"type":"epargne" , "code":2, "solde":9600,"dateCreation":1596711179308}
]
Les structures de données JSON

• En JSON, les structures de données prennent


les formes suivantes :
• Un objet, qui est un ensemble de couples nom/valeur
non ordonnés. Un objet commence par { (accolade
gauche) et se termine par } (accolade droite). Chaque
nom est suivi de : (deux-points) et les couples
nom/valeur sont séparés par , (virgule).
• Un tableau est une collection de valeurs ordonnées.
Un tableau commence par [ (crochet gauche) et se
termine par ] (crochet droit). Les valeurs sont séparées
par , (virgule).
• Une valeur peut être soit une chaîne de
caractères entre guillemets, soit un nombre,
soit true ou false ou null, soit un objet soit un tableau.
Ces structures peuvent être imbriquées.
• Une chaîne de caractères est une suite de zéro
ou plus caractères Unicode, entre guillemets, et
utilisant les échappements avec antislash. Un caractère
est représenté par une chaîne d'un seul caractère.
JAX RS: Application

Web Container : Tomcat

Client Jersey JAXRS


HTTP, XML
REST Servlet
CLIENT
HTTP, JSON Web Service Compte
REST
- Code : Long
getCompte(Long code) : Compte - Solde: double
listComptes() : List<Compte> - dateCreation:Date
Implémentation d’un Web service RESTful avec JAX RS

@Path("/banque")
• Le développement de Services Web avec JAX-RS est public class BaqueRestService {
basé sur des POJO (Plain Old Java Object) en utilisant
des annotations spécifiques à JAX-RS @Path("/comptes")
@GET
• Pas description requise dans des fichiers de @Produces(MediaType.APPLICATION_JSON)
configuration public List<Compte> listComptes() {
• Seule la configuration de la Servlet « JAX-RS » est List<Compte> cptes=new ArrayList<>();
requise pour réaliser le pont entre les requetés HTTP et ...

les classes Java annotées return cptes;


}
• Un Service Web REST est déployé dans une application @Path("/comptes/{code}")
Web @GET

• Contrairement aux Services Web entendus il n’y a pas


@Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
public Compte getCompte(@PathParam(value="code")Long code) {
de possibilité de développer un service REST à partir du return new Compte(1L, [Link]()*9999, new Date());
fichier de description WADL }
• Seule l’approche Botton / Up est disponible @Path("/comptes")
@POST
• Créer et annoter un POJO @Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
• Compiler, Déployer et Tester public Compte save(Compte cp) {
...
• Possibilité d’accéder au document WADL
return cp;
• Le fichier de description WADL est génèré }
automatiquement par JAX-RS (exemple :
[Link]
Implémentation d’un Web service RESTful avec JAX RS

@Path("/comptes/{code}")
• Le développement de Services Web avec JAX-RS est @PUT
basé sur des POJO (Plain Old Java Object) en utilisant @Produces(MediaType.APPLICATION_JSON)
des annotations spécifiques à JAX-RS public Compte update(@PathParam("code")Long code,Compte cp) {
[Link](code);
• Pas description requise dans des fichiers de // .. Mise à jour du compte
configuration [Link]("Mise à jour du compte :"+[Link]());
• Seule la configuration de la Servlet « JAX-RS » est return cp;
requise pour réaliser le pont entre les requetés HTTP et }

les classes Java annotées


@Path("/comptes/{code}")
• Un Service Web REST est déployé dans une application @DELETE
Web @Produces(MediaType.APPLICATION_JSON)

• Contrairement aux Services Web entendus il n’y a pas


public void delete(@PathParam("code")Long code) {
// .. Suppression du compte
de possibilité de développer un service REST à partir du [Link]("Suppression du compte :"+code);
fichier de description WADL }
• Seule l’approche Botton / Up est disponible }

• Créer et annoter un POJO


@XmlRootElement
• Compiler, Déployer et Tester public class Compte {
• Possibilité d’accéder au document WADL private Long code; private double solde;
private Date dateCreation;
• Le fichier de description WADL est génèré // Getters et Setters
automatiquement par JAX-RS (exemple : // Constructeurs
[Link] }
Structure du projet Maven

<dependency> <plugin>
<groupId>javax</groupId> <groupId>[Link]</groupId>
<artifactId>javaee-web-api</artifactId> <artifactId>tomcat7-maven-plugin</artifactId>
<version>7.0</version> <version>2.2</version>
<scope>provided</scope> <configuration>
</dependency> <port>8080</port>
<dependency> <path>/web-api</path>
<groupId>[Link]</groupId> </configuration>
<artifactId>jersey-server</artifactId> </plugin>
<version>1.19.4</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>jersey-servlet</artifactId>
<version>1.19.4</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>jersey-json</artifactId>
<version>1.19.4</version>
</dependency>
Déploiement de Jersey : [Link]

<?xml version="1.0" encoding="UTF-8"?>


<web-app xmlns:xsi="[Link]
xmlns="[Link] xsi:schemaLocation="[Link]
[Link] version="2.5">
<servlet>
<servlet-name>rs</servlet-name>
<servlet-class>[Link]</servlet-class>
<init-param>
<param-name>[Link]</param-name>
<param-value>service</param-value>
</init-param>
<init-param>
<param-name>[Link]</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>rs</servlet-name>
<url-pattern>/api/*</url-pattern>
</servlet-mapping>
</web-app>
Déploiement de Jersey : [Link]

@Path("/") @XmlRootElement
public class BanqueRestService { @Data @AllArgsConstructor
static Map<Long,Compte> banque=new HashMap<>();
@GET @Path("/test") @NoArgsConstructor
public String test(){ return "Test Jersey"; } public class Compte {
@GET @Path("/comptes/{code}") private Long id;
@Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON}) private double solde;
public Compte getCompte(@PathParam(value="code") Long code){ private Date dateCreation;
return [Link](code);
}
}
@GET @Path("/comptes") @Produces(MediaType.APPLICATION_JSON)
public Collection<Compte> listComptes(){
return [Link]();
}
@Path("/comptes") @POST @Produces(MediaType.APPLICATION_JSON)
public Compte save(Compte cp){
if([Link]([Link]())!=null) throw new RuntimeException("Ce compte existe déjà");
[Link](new Date());
[Link]([Link](),cp);
return cp;
}
@Path("/comptes/{code}") @PUT @Produces(MediaType.APPLICATION_JSON)
public Compte update(@PathParam("code") Long code,Compte cp){
[Link](code); [Link]([Link](),cp); return cp;
}
@Path("/comptes/{code}") @DELETE @Produces(MediaType.APPLICATION_JSON)
public Compte delete(@PathParam("code") Long code){
return [Link](code);
}
}
Test du Web service RESTful
Test du Web service RESTful
WADL : Web Application Description
Langage

• WADL est un fichier XML qui permet


de faire la description des services web
d’une application basée sur REST.
• Le WADL est généré automatiquement
par le conteneur REST.
[Link]
api/api/[Link]
• Les types de données structurés
échangés via ce web service sont
décrites par un schéma XML lié au
WSDL.
• Le schéma xml de l’application REST
peut être consulté par l’adresse de
suivante : [Link]
api/api/[Link]/[Link]
JaxRS dans un projet Spring Boot public interface CompteRepository extends JpaRepository<Compte, Long> {}

@Component
@Path("/banque") @Entity @Data
public class BanqueRestService { @AllArgsConstructor
@Autowired @NoArgsConstructor
private CompteRepository compteRepository; public class Compte {
@Id @GeneratedValue
@Path("/comptes") @GET private Long code;
@Produces(MediaType.APPLICATION_JSON) private double solde;
public List<Compte> listComptes() { private Date dateCreation;
return [Link]();
} }
@Path("/comptes/{code}")
@GET @Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
public Compte getCompte(@PathParam(value="code")Long code) {
return [Link](code);
}
@Path("/comptes")
@POST @Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
public Compte save(Compte cp) {
[Link](cp);
return cp;
}
@Path("/comptes/{code}") @PUT @Produces(MediaType.APPLICATION_JSON)
@Configuration public Compte update(@PathParam("code")Long code,Compte cp) {
public class MyConfig { [Link](code); [Link](cp);
@Bean return cp;
public ResourceConfig getJaxRSExporter() { }
ResourceConfig exporter=new ResourceConfig(); @Path("/comptes/{code}") @DELETE @Produces(MediaType.APPLICATION_JSON)
[Link]([Link]); public void delete(@PathParam("code")Long code) {
return exporter; [Link](code);
} }
} }
Web Service Restful avec Spring MVC @RestController
@RequestMapping(value="/banque")
public class BanqueRestServiceRC {
@Autowired
• Spring MVC offre des annotations qui permettent de private CompteRepository compteRepository;
créer facilement des web services Restful, sans avoir @GetMapping("/comptes")
public List<Compte> listComptes() {
besoin d’utiliser JAXRS. return [Link]();
• Les annotations principales suivantes peuvent être }
@GetMapping("/comptes/{code}")
utilisées pour ce fait: public Compte getCompte(@PathVariable(value="code")Long code) {
• @RestController : Pour annoter le web service return [Link](code);
}
• @RequestMapping : Pour associer une requête HTTP quelconque @PostMapping("/comptes")
public Compte save(@RequestBody Compte cp) {
• @GetMapping : Pour associer une requête HTTP de type GET [Link](cp);
• @PostMapping : Pour associer une requête HTTP de type POST return cp;
}
• @PutMapping : Pour associer une requête HTTP de type PUT @PutMapping("/comptes/{code}")
public Compte update(@PathVariable(value="code")Long code,Compte cp) {
• @DeleteMapping : Pour associer une requête HTTP de type
[Link](code);
DELETE [Link](cp);
• @RequestBody : Pour associer le corps de la requête HTTP à un return cp;
}
paramètre d’une méthode du web service
@DeleteMapping("/comptes/{code}")
• @PathVariable : Pour associer un paramètre de path URL un public void delete(@PathVariable(value="code")Long code) {
paramètre d’une méthode du web service [Link](code);
}
• @RequestParam : Pour associer un Query param à un paramètre }
d’une méthode du web service
Web Service Restful avec Spring Data Rest

• Spring Data rest offre un moyen très


rapide qui permet d’exposer une API
Rest.
• Il suffit d’utiliser l’annotation
@RespositoryRestResource dans
l’interface Spring Data pour que
toutes les méthodes de cette
interfaces soient accessibles via une
API Rest générée automatiquement.

<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>

@RepositoryRestResource
public interface CompteRepository extends JpaRepository<Compte, Long> {
}
<dependency>
Client REST Java avec Jersey <groupId>[Link]</groupId>
Client <artifactId>jersey-client</artifactId>
<version>1.19.4</version>
</dependency>
Server
<dependency>
<groupId>[Link]</groupId> Client Java
<artifactId>jersey-json</artifactId>
<version>1.19.4</version> HTTP
</dependency> Jersey Client JSON API REST

ClientConfig config=new DefaultClientConfig();


Client client=[Link](config);
URI uri=[Link]("[Link]
WebResource service=[Link](uri);
WebResource resource=[Link]("banque").path("comptes");
/*
* Ajouter un compte : POST [Link]
* {"solde":9999,"dateCreation":1514110620417}
*/
Compte cp=new Compte(); [Link]=9999;[Link]=new Date(); package test;
ObjectMapper mapper=new ObjectMapper(); import [Link];
ClientResponse resp1=resource public class Compte {
.accept("application/json").type("application/json") public Long code;
.post([Link],[Link](cp)); public double solde;
[Link]("Status Code:"+[Link]()); public Date dateCreation;
String corpsReponse=[Link]([Link]); }
[Link]("Corps Réponse:"+corpsReponse);
Compte cp1=[Link](corpsReponse, [Link]);
[Link]("Code="+[Link]); [Link]("Solde="+[Link]);
[Link]("Date Création="+[Link]);
/* GET [Link] */
String resp2=[Link]([Link]);
[Link](resp2);
Compte[] cptes=[Link](resp2, Compte[].class);
Client REST avec Spring RestTEmplate

@RestController Client REST Web Service


class ClientRestController{
@Autowired Spring
private RestTemplate restTemplate; Rest
private String url="[Link] Browser Web http, JSON REST D
Templat
@GetMapping("/listComptes") e
public String listCompte(){
HttpHeaders headers = new HttpHeaders();
[Link]([Link](MediaType.APPLICATION_JSON));
HttpEntity<String> entity = new HttpEntity<String>(headers);
ResponseEntity<String> responseEntity=[Link](url+"/comptes", [Link], entity, [Link]);
String response=[Link]();
return response; @Bean
} public RestTemplate restTemplate(){
return new RestTemplate();
@GetMapping("/listComptes2") }
public Compte listCompte2(){
Compte cp=[Link](url+"/comptes/1",[Link]);
return cp;
} @Data
@GetMapping("/listComptes3") class Compte{
public List<Compte> listCompte3(){ private Long id;
List<Compte> comptes=[Link](url+"/comptes",[Link]); private double solde;
return comptes; private Date dateCreation;
} }
@PostMapping("/comptes")
public Compte save(@RequestBody Compte cp){
Compte compte= [Link](url+"/comptes",new HttpEntity<Compte>(cp),[Link]);
return compte; @PostMapping("/save")
} public Compte save2(@RequestBody Compte cp){
} ResponseEntity<Compte> response= [Link](url+"/comptes",[Link],new HttpEntity<>(cp),[Link]);
return [Link]();
}
Application Spring Web Services : Use Case
Web Service Consummer Web Service Provider
Spring Boot IOC Containner Spring Boot IOC Containner
Web Service Web DAO
<<Entity>>
SoapClient Compte
ServiceImpl <<interface>>
CompteRepository
CompteRest Compte SOAP
Soap SOAP
API Service Spring Data
Proxy
JPA

Hibernate

WSDL JaxB2 JaxB2 JDBC

http SOAP
JSON WSDL
SGBD
Web Client SoapUI

Vous aimerez peut-être aussi