Partie 1 : Définitions et concepts généraux (hors SOAP et
REST)
Concepts clés de SOA (Architecture Orientée Services)
1. Définition de SOA :
o SOA (Service-Oriented Architecture) est un modèle de conception où les
composants logiciels sont organisés sous forme de services autonomes,
réutilisables, et communiquant via un réseau.
o Ces services sont décrits par des contrats standards (souvent en WSDL) et
peuvent être découverts et consommés dynamiquement.
2. Éléments principaux de SOA :
o Service : Une unité fonctionnelle autonome qui répond à un besoin spécifique.
o Contrat de service : Définit les données d’entrée, de sortie et les règles
d’utilisation.
o Registre de services (UDDI) : Permet de découvrir et publier les services.
o Bus d’Entreprise (ESB) : Middleware facilitant la communication entre
services.
3. Avantages de SOA :
o Réutilisation : Facilite le développement rapide grâce à des services déjà
existants.
o Maintenance : Les services peuvent être mis à jour sans affecter les autres.
o Interopérabilité : Fonctionne entre différentes plateformes et langages.
4. Défis liés à SOA :
o Gestion des versions de services.
o Orchestration complexe et sécurité des services.
o Performances réduites dans des environnements très distribués.
Technologies basées sur XML
1. XML :
o Langage de balisage extensible utilisé pour structurer les données.
o Exemple de document XML :
xml
Copy code
<?xml version="1.0"?>
<livre>
<titre>Introduction à SOA</titre>
<auteur>Jean Dupont</auteur>
</livre>
2. Schéma XML (XSD) :
o Définit la structure et les types de données acceptés dans un document XML.
o Exemple d’un schéma XML :
xml
Copy code
<xs:element name="livre">
<xs:complexType>
<xs:sequence>
<xs:element name="titre" type="xs:string"/>
<xs:element name="auteur" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
3. XSLT : Utilisé pour transformer les documents XML en d'autres formats (HTML,
texte, etc.).
4. XPath :
o Langage de requête permettant de naviguer dans les documents XML.
o Exemples :
/livre/titre : Sélectionne l’élément <titre> dans <livre>.
//auteur : Sélectionne tous les éléments <auteur>.
Types et Protocoles de Services Web
1. Services Web :
o Application accessible via un réseau, souvent en utilisant XML pour échanger
les données.
o Caractéristiques :
Indépendance des plateformes.
Communication via HTTP, HTTPS, FTP, etc.
2. Types de Services Web :
o XML-RPC : Protocole simple basé sur XML pour les appels de procédures
distants.
o SOAP : Protocole riche basé sur XML pour des interactions complexes.
o REST : Style architectural léger utilisant les méthodes HTTP et les URIs.
3. Standards :
o WSDL : Langage pour décrire les services web.
o UDDI : Registre pour découvrir et publier les services.
Partie 2 : SOAP
Cycle de Vie de SOAP :
1. Définir le service (contrat WSDL).
2. Déployer le service sur un serveur SOAP.
3. Publier le WSDL dans un registre.
4. Générer les clients pour consommer le service.
Code de Base pour un Service SOAP :
1. Interface du Service :
import javax.jws.WebService;
@WebService
public interface ServiceBonjour {
String direBonjour(String nom);
}
2. Implémentation du Service :
import javax.jws.WebService;
@WebService(endpointInterface = "ServiceBonjour")
public class ServiceBonjourImpl implements ServiceBonjour {
public String direBonjour(String nom) {
return "Bonjour, " + nom + "!";
}
}
3. Publication du Service :
import javax.xml.ws.Endpoint;
public class ServeurSOAP {
public static void main(String[] args) {
Endpoint.publish("http://localhost:8080/ws/bonjour", new
ServiceBonjourImpl());
System.out.println("Service SOAP publié !");
}
}
4. Consommation du Service (Client) :
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import java.net.URL;
public class ClientSOAP {
public static void main(String[] args) throws Exception {
URL wsdl = new URL("http://localhost:8080/ws/bonjour?wsdl");
QName qname = new QName("http://ws/", "ServiceBonjourImplService");
Service service = Service.create(wsdl, qname);
ServiceBonjour proxy = service.getPort(ServiceBonjour.class);
System.out.println(proxy.direBonjour("Alice"));
}
}
Partie 3 : REST
Cycle de Vie de REST :
1. Définir les ressources et les URIs.
2. Implémenter les méthodes HTTP (GET, POST, PUT, DELETE).
3. Déployer et tester via Postman ou Curl.
Code de Base pour un Service REST :
1. Ressource REST :
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
@Path("/bonjour")
public class RessourceBonjour {
@GET
@Path("/{nom}")
@Produces(MediaType.TEXT_PLAIN)
public String direBonjour(@PathParam("nom") String nom) {
return "Bonjour, " + nom + "!";
}
}
2. Application Principale :
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.jetty.JettyHttpContainerFactory;
import java.net.URI;
public class ServeurREST {
public static void main(String[] args) {
URI baseUri = URI.create("http://localhost:8080/api/");
ResourceConfig config = new ResourceConfig(RessourceBonjour.class);
JettyHttpContainerFactory.createServer(baseUri, config);
System.out.println("Service REST en cours d'exécution sur " +
baseUri);
}
}
3. Consommation du Service (Client) :
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.core.MediaType;
public class ClientREST {
public static void main(String[] args) {
Client client = ClientBuilder.newClient();
String response =
client.target("http://localhost:8080/api/bonjour/John")
.request(MediaType.TEXT_PLAIN)
.get(String.class);
System.out.println(response);
}
}
Avantages par rapport à une approche monolithique
■ Mise sur le marché accélérée et plus grande flexibilité
■ Utilisation de l'infrastructure existante sur les nouveaux marchés
■ Coûts réduits grâce à une meilleure agilité et à un développement plus
■ Maintenance facilitée
■ Évolutivité
■ Fiabilité améliorée
■ Grande disponibilité
