Contexte et Rappel Historique
1. Origines et tentatives précédentes :
o CORBA, DCOM, RMI : ces approches étaient limitées par leur complexité, leur
dépendance au langage ou à la plateforme.
o Besoins émergents : simplicité, indépendance des langages, interopérabilité, et
adoption rapide par les responsables des systèmes d'information (SI).
2. Le Web comme support :
o HTTP universel, extensible avec XML pour le transport des données.
o Avantages : adoption généralisée, simplicité relative, indépendance du langage et de
la plateforme.
Les Services Web
1. Définition selon le W3C :
Un service Web est une application logicielle identifiée par une URI, utilisant des messages XML
pour interagir avec d'autres applications via des protocoles Internet.
2. Propriétés clés :
o Interopérabilité entre différents systèmes.
o Utilisation d'HTTP et XML pour simplifier la communication et réduire le couplage.
3. Technologies utilisées :
o SOAP : pour les appels de procédures distants.
o WSDL : pour décrire l'interface du service au format XML.
o UDDI : pour la découverte et la publication des services.
Architectures Orientées Services (SOA)
1. Caractéristiques :
o Modèle distribué avec faible couplage entre les composants.
o Décomposition des fonctionnalités en services combinables.
o Interactions entre trois acteurs principaux : fournisseur, registre, client.
2. Composants principaux :
o SOAP (Simple Object Access Protocol) :
Fournit un protocole standardisé pour les échanges de données.
Fonctionne au-dessus d'HTTP.
o WSDL (Web Service Description Language) :
Indépendance des langages et plateformes.
Définit les méthodes, paramètres, protocoles, et localisations des services.
o UDDI (Universal Description, Discovery, and Integration) :
Annuaire facilitant la découverte et la collaboration interentreprises.
Retours sur XML
1. Avantages par rapport à HTML :
o Définition libre des balises.
o Support de structures complexes.
o Séparation claire entre contenu et présentation.
2. Limites :
o Verbeux.
o Peut nécessiter une bande passante plus importante que d'autres approches.
Comparaison avec les Modèles Précédents
1. Avantages des Services Web :
o Moins complexes que CORBA et RMI.
o Passage des firewalls via HTTP.
o Extensibilité grâce à XML.
2. Inconvénients :
o Moins performants que les systèmes fortement couplés.
o Verbeux et parfois peu « simple » en pratique.
Cas d'utilisation et Applications
1. Interaction entre systèmes distribués :
o Applications B2B (business-to-business).
o Consommation de services via des clients légers ou Web.
2. Découverte et intégration rapide des services :
o Annuaire UDDI pour la publication et la découverte de services adaptés à des besoins
spécifiques (fonctionnalités, QoS).
++++++TP
1. Composition des Services Web
Problématique
But : Combiner plusieurs petits services pour en créer des plus complexes, adaptés aux besoins
métiers.
Exemple : Inscription d’un étudiant, regroupant plusieurs étapes :
1. Inscription à l’école.
2. Paiement des frais via un service bancaire.
3. Recherche de logement.
4. Abonnement aux transports.
Solution
1. L'utilisateur visite chaque site individuellement (peu pratique).
2. Service composite : Un seul point d’entrée qui combine et orchestre tous les services
nécessaires.
Approches
Orchestration : Contrôle centralisé.
Chorégraphie : Coordination décentralisée.
2. Orchestration des Services
Définition : Définit un processus centralisé contrôlé par un maître (souvent un moteur
d’orchestration) pour coordonner les services.
Technologies utilisées :
o BPMN (Business Process Modeling Notation) : Représentation visuelle des étapes du
processus.
o BPEL (Business Process Execution Language) : Décrit et exécute le processus sous forme
XML.
Avantages
Contrôle centralisé.
Adapté à des services intra-organisationnels.
Bonne intégration avec une architecture orientée services (SOA).
Limites
Faible tolérance aux pannes (point de défaillance unique).
Difficulté de passage à l’échelle pour des processus complexes.
3. Chorégraphie des Services
Définition : Approche décentralisée où chaque service interagit avec les autres selon des règles
bien définies.
Cas d’usage :
o Processus complexes impliquant plusieurs parties autonomes.
o Systèmes événementiels ou multi-agents.
Avantages
Meilleure tolérance aux pannes (absence de point central).
Inter-organisationnel : chaque partie conserve son autonomie.
Interaction peer-to-peer.
Limites
Complexité accrue dans la coordination.
Les participants doivent connaître leurs rôles et interactions.
4. Orchestration vs. Chorégraphie
Critères Orchestration Chorégraphie
Contrôle Centralisé (maître) Décentralisé
(autonome)
Connaissance du Seul le contrôleur connaît Chaque service connaît
processus l’objectif son rôle
Type d’interaction Intra-organisationnel Inter-organisationnel
Nature des Processus dirigé Interaction peer-to-
interactions peer
5. Standards et outils
BPMN : Modélisation graphique.
BPEL : Langage XML pour l'exécution
6. Implementing RESTful Services with Java
JAX-RS (Java API for RESTful Web Services):
o Part of Java EE 6 specification.
o Key Implementations:
Jersey (Oracle): Reference implementation.
Apache CXF: Open-source alternative.
RESTEasy (JBOSS): Another popular choice.
RESTLET: Early framework for REST in Java.
Example JAX-RS Setup
Annotations:
o @Path: Map URI to a resource.
o @GET, @POST, etc.: Map HTTP methods to Java methods.
o @Produces, @Consumes: Specify data formats.
1. HTTP Request Example
http
Copier le code
POST /bibliotheque/faces/views/categorie/Create.xhtml HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Content-Length: 176
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Origin: http://localhost:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_0) AppleWebKit/537.36 (KHTML, like
Gecko) Chrome/ 39.0.2171.65 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Referer: http://localhost:8080/bibliotheque/faces/views/categorie/List.xhtml
Accept-Encoding: gzip, deflate
Accept-Language: fr,fr-FR;q=0.8,en;q=0.6
Cookie: JSESSIONID=d64a9484e61761662575b5d14af1
{ "name": "Category", "description": "New category description" }
2. HTTP Response Example
http
Copier le code
HTTP/1.1 200 OK
Date: Thu, 09 Dec 2004 12:07:48 GMT
Server: IBM_CICS_Transaction_Server/3.1.0(zOS)
Content-Type: image/jpg
<content of the resource or data>
3. JSON Representation Example
Object Example
json
Copier le code
{"id":51,"nom":"Mathematiques 1","resume":"Resume of math","isbn":"123654","categorie":
{"id":2,"nom":"Mathematiques","description":"Description of
mathematiques"},"quantite":42,"photo":""}
Array Example
json
Copier le code
[{"id":51,"nom":"Mathematiques 1","resume":"Resume of
math","isbn":"123654","quantite":42,"photo":""},{"id":102,"nom":"Mathematiques
2","resume":"Advanced math topics","isbn":"12365444455","quantite":20,"photo":""}]
4. BPEL Example
xml
Copier le code
<processname="BusinessTravelProcess"><partnerLinks><!-- The declaration of partner links
--></partnerLinks><variables><!-- The declaration of variables --></variables><sequence><!-- The
definition of the BPEL business process main body --></sequence></process>
Voici un guide complet pour créer une API SOAP en Java avec validation XSD. L’architecture de
votre projet inclut la création du service SOAP, la gestion des fichiers XSD pour la validation, et un
exemple de structure pour tester le service.
1. Configurer le projet Java avec Maven
Ajoutez les dépendances Maven nécessaires dans votre fichier pom.xml pour SOAP et JAXB.
<dependencies>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>javax.jws</groupId>
<artifactId>javax.jws-api</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>com.sun.xml.ws</groupId>
<artifactId>jaxws-ri</artifactId>
<version>2.3.2</version>
</dependency>
</dependencies>
2. Créer le fichier XSD : produit.xsd
Ce fichier XSD décrit la structure du produit. Il sera utilisé pour valider les messages XML reçus par
l'API.
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="Produit">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Nom" type="xsd:string"/>
<xsd:element name="Prix" type="xsd:decimal"/>
<xsd:element name="Quantite" type="xsd:int"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
3. Générer les classes Java avec JAXb
Exécutez la commande suivante pour générer les classes Java à partir du fichier XSD :
xjc -d src/main/java -p com.example.produit produit.xsd
Cela créera les classes Java sous le package com.example.produit.
4. Créer le service SOAP : ProduitService.java
Le service SOAP expose une méthode ajouterProduit qui prend les informations d'un produit.
package com.example.soap;
import javax.jws.WebMethod;
import javax.jws.WebService;
@WebService
public class ProduitService {
@WebMethod
public String ajouterProduit(String nom, double prix, int quantite) {
return "Produit ajouté : " + nom + ", Prix : " + prix + ", Quantité : " + quantite;
}
}
5. Créer le serveur SOAP : Server.java
Ce fichier démarre le service SOAP sur le serveur local.
package com.example.soap;
import javax.xml.ws.Endpoint;
public class Server {
public static void main(String[] args) {
String url = "http://localhost:8080/produit";
Endpoint.publish(url, new ProduitService());
System.out.println("Service SOAP démarré à : " + url);
}
}
6. Validation XML avec XSD : XMLValidator.java
Cette classe permet de valider un fichier XML par rapport à un schéma XSD.
package com.example.utils;
import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import java.io.File;
public class XMLValidator {
public static boolean validateXML(String xmlFile, String xsdFile) {
try {
SchemaFactory factory =
SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = factory.newSchema(new File(xsdFile));
Validator validator = schema.newValidator();
validator.validate(new StreamSource(new File(xmlFile)));
return true;
} catch (Exception e) {
System.err.println("Validation error: " + e.getMessage());
return false;
}
}
}
7. Tester le service
Vous pouvez envoyer une requête SOAP au service avec ce corps XML.
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:prod="http://example.com/soap">
<soapenv:Header/>
<soapenv:Body>
<prod:ajouterProduit>
<nom>Pommes</nom>
<prix>3.50</prix>
<quantite>100</quantite>
</prod:ajouterProduit>
</soapenv:Body>
</soapenv:Envelope>
8. Structure du projet
Voici une suggestion de structure pour votre projet :
src/
├── main/
│ ├── java/
│ │ └── com/
│ │ └── example/
│ │ ├── model/ # Classes générées ou définies à partir du XSD
│ │ │ └── Produit.java
│ │ ├── service/ # Classes pour le service SOAP
│ │ │ ├── ProduitService.java
│ │ │ └── Server.java
│ │ ├── utils/ # Classes utilitaires (validation, logs, etc.)
│ │ │ └── XMLValidator.java
│ │ └── exceptions/ # Gestion des erreurs spécifiques
│ │ └── ValidationException.java
│ ├── resources/
│ │ ├── wsdl/ # Fichiers WSDL pour le service SOAP
│ │ │ └── produit.wsdl
│ │ ├── xsd/ # Schémas XML (XSD)
│ │ │ └── produit.xsd
│ │ └── application.properties # Configuration (port, logs, etc.)
│ └── webapp/
│ └── WEB-INF/
│ └── web.xml # Configuration pour le déploiement
└── test/
└── java/
└── com/
└── example/
└── service/
└── ProduitServiceTest.java
9. Ajouter le fichier WSDL : produit.wsdl
Le fichier WSDL décrit l'interface du service SOAP.
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:tns="http://example.com/produit"
targetNamespace="http://example.com/produit">
<types>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://example.com/produit">
<xsd:import namespace="http://example.com/produit"
schemaLocation="produit.xsd"/>
</xsd:schema>
</types>
<!-- Définition des opérations -->
</definitions>
10. Ajouter les configurations dans application.properties
Définissez les configurations du serveur et des logs.
server.port=8080
logging.level.com.example=DEBUG
soap.service.url=http://localhost:8080/produit
11. Déploiement dans web.xml
Enfin, configurez votre déploiement avec le fichier web.xml.
<web-app>
<display-name>ProduitService</display-name>
<listener>
<listener-class>com.sun.xml.ws.transport.http.servlet.WSServletContextListener</listener-
class>
</listener>
<servlet>
<servlet-name>ProduitService</servlet-name>
<servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>ProduitService</servlet-name>
<url-pattern>/produit</url-pattern>
</servlet-mapping>
</web-app>
Conclusion
Cette architecture complète pour une API SOAP en Java inclut la création d'un service avec
validation XML via XSD, un serveur SOAP exposant l'API, et un processus de validation et de test.
Assurez-vous que tous les composants sont correctement configurés avant de déployer et tester
l'application.
