Module : Microservices
TP : Produire et consommer un service web en utilisant SOAP et Spring
Boot
Outil de développement
• spring tool suite :
https://spring.io/blog/2021/06/21/spring-tools-4-11-0-released
New Project Starter
Cliquez par la suite sur
NEXT
1- Faites une recherche sur les dépendances avec le mot 'web’.
2- Ensuite, veuillez cocher la dépendance 'Spring Web Services'.
Spring Web Services est un module de Spring qui facilite la
création de services web SOAP robustes et interopérables en
suivant une approche orientée message et "contract-first".
Il s'intègre parfaitement avec l'écosystème Spring, offrant une
abstraction de transport et une facilité de test
pour les services web SOAP.
1- Faites une recherche sur les dépendances avec le mot dev’.
2- Ensuite, veuillez cocher la dépendance 'Spring Boot DevTools'.
Spring Boot DevTools est un ensemble d'outils
supplémentaires qui peuvent être inclus dans un projet Spring
Boot pour faciliter le développement local, comme le
rechargement automatique des changements de code, les
configurations par défaut pour le développement, et des
fonctionnalités de débogage améliorées.
Pom.xml
Le pom.xml est un fichier XML utilisé par Apache Maven, un outil de gestion et
d'automatisation de projet pour les projets Java. Il contient des informations sur le
projet et les configurations de détail telles que:
• Les dépendances du projet: Bibliothèques externes dont le projet a besoin pour
compiler et/ou s'exécuter.
• Les plugins: Outils qui fournissent des tâches supplémentaires et des capacités de
personnalisation lors de la construction du projet.
• Les objectifs de build (goals): Tâches spécifiques à exécuter lors de la construction
du projet.
• Les profils de build: Configurations spécifiques pour différents environnements ou
situations de build.
• Les informations sur le projet: Comme la version, la description, l'URL du projet, les
développeurs, les licences, etc.
Erreur susceptible
• Dans le cas où votre fichier pom.xml génère des erreurs signalées en
rouge dans l'en-tête, vérifiez que la balise ouvrante correspond à ce
qui suit :
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
WSDL
Pour travailler avec des fichiers WSDL (Web Services Description Language) dans
un projet Spring Boot, vous pouvez utiliser la dépendance spring-boot-starter-
web-services qui inclut les outils nécessaires pour construire des services web
SOAP. Cette dépendance ajoute le support de Spring Web Services qui facilite la
création et la consommation de services web basés sur SOAP.
• Voici comment vous pourriez ajouter cette dépendance dans votre fichier
pom.xml si vous utilisez Maven :
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web-services</artifactId>
</dependency>
WSDL
• Par la suite, nous avons besoin de générer des classes Java à partir de
fichiers WSDL.
• Pour cela, nous pouvons utiliser le plugin jaxb2-maven-plugin ou cxf-
codegen-plugin dans notre pom.xml.
• Ces plugins peuvent être configurés pour générer automatiquement
des classes basées sur nos fichiers WSDL lors de la construction de
notre projet.
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>jaxb2-maven-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>xjc</id>
<goals>
<goal>xjc</goal>
</goals>
</execution>
</executions>
<configuration>
<sources>
<source>${project.basedir}/src/main/resources/loaneligibility.xsd</s
ource>
</sources>
<outputDirectory>${project.basedir}/src/main/java</outputDirectory>
<clearOutputDir>false</clearOutputDir>
</configuration>
</plugin>
Ce morceau de code est une configuration pour le `jaxb2-maven-plugin` dans un fichier `pom.xml` utilisé par
Maven pour la gestion de projets Java.
Voici une explication de chaque partie du code :
- <plugin> : Cette balise déclare un plugin utilisé pendant le processus de construction du projet Maven.
- <groupId> : Identifie le groupe ou l'organisation qui a créé le plugin. Ici, `org.codehaus.mojo` est le groupe qui
fournit le plugin `jaxb2-maven-plugin`.
- <artifactId> : Le nom du plugin. Dans ce cas, `jaxb2-maven-plugin` est un plugin qui permet de générer des
classes Java à partir de fichiers XSD (XML Schema Definition).
- <version> : La version du plugin à utiliser. Ici, la version est spécifiée comme `3.1.0`.
- <executions> : Cette balise contient une ou plusieurs `<execution>` qui définissent quand et comment le
plugin doit être exécuté.
- <execution> : Une instance d'exécution du plugin.
- <id> : Un identifiant unique pour cette exécution. Ici, il est défini comme `xjc`, qui est souvent utilisé pour indiquer que cette exécution
concerne la génération de code Java à partir de XSD.
- <goals> : Définit les objectifs (goals) spécifiques du plugin à exécuter. Dans ce cas, `<goal>xjc</goal>` indique que le but de cette exécution
est de lancer le compilateur XJC qui transforme les fichiers XSD en classes Java.
- <configuration> : Contient les paramètres de configuration pour le plugin.
- <sources> : Spécifie l'emplacement des fichiers sources à utiliser pour la génération de code.
- <source>: Le chemin d'accès au fichier XSD à partir duquel générer les classes Java.
Ici, `${project.basedir}/src/main/resources/loaneligibility.xsd` indique que le fichier `loaneligibility.xsd` se trouve dans le répertoire
`resources` du projet.
- <outputDirectory>: Le répertoire où les fichiers générés seront placés.
Ici, `${project.basedir}/src/main/java` indique que les classes Java générées doivent être placées dans le répertoire `java` du projet, qui est le
répertoire standard pour le code source Java dans un projet Maven.
- <clearOutputDir>: Un paramètre qui indique si le répertoire de sortie doit être vidé avant la génération des classes. `false` signifie que le
contenu existant ne sera pas supprimé.
Pom.xml final (part1)
Pom.xml final (part2)
Fichier loaneligibility.xsd
Fichier loaneligibility.xsd
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
code targetNamespace="http://www.example.com/soap/ws/loanEligibility"
xmlns:tns="http://www.example.com/soap/ws/loanEligibility"
elementFormDefault="qualified">
<xsd:element name="CustomerRequest">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="customerName" type="xsd:string" />
<xsd:element name="age" type="xsd:int" />
<xsd:element name="yearlyIncome" type="xsd:long" />
<xsd:element name="cibilScore" type="xsd:int" />
<xsd:element name="employmentMode" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="Acknowledgement">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="isEligible" type="xsd:boolean" />
<xsd:element name="approvedAmount" type="xsd:long" />
<xsd:element name="CriteriaMismatch" type="xsd:string"
maxOccurs="unbounded" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
Explication du fichier
Le but de ce fichier XSD (XML Schema Definition) est de définir la structure et le type de données des messages
échangés entre un client et un service web dans le cadre d'un processus d'évaluation de l'éligibilité à un prêt. Il sert de
contrat entre le client et le service web, garantissant que les messages envoyés et reçus suivent un format convenu et
contiennent les informations nécessaires pour le traitement des demandes de prêt.
En détail, ce fichier XSD spécifie :
1. La structure des données pour une requête client (`CustomerRequest`), incluant le nom du client, l'âge, le revenu
annuel, le score CIBIL (un score de crédit utilisé par les banques en Inde), et le mode d'emploi.
2. La structure des données pour la réponse du service (`Acknowledgement`), indiquant si le client est éligible ou non
pour un prêt, le montant du prêt approuvé et une liste des critères non satisfaits si le client n'est pas éligible.
Ce fichier est essentiel pour la génération de classes Java à l'aide de JAXB (Java Architecture for XML Binding) ou
d'autres outils similaires, qui peuvent ensuite être utilisées pour développer le service web et le client consommant ce
service. Les classes générées permettent de manipuler les données des messages SOAP de manière typée et orientée
objet, facilitant ainsi le développement, la maintenance et l'assurance qualité du service web.
Voici une explication détaillée de ses composants :
• <?xml version="1.0" encoding="UTF-8"?> : La déclaration XML standard qui spécifie que le document est en XML et utilise l'encodage UTF-8.
•
• <xsd:schema> : L'élément racine du document XSD qui définit l'espace de noms XML Schema
(xmlns:xsd="http://www.w3.org/2001/XMLSchema") et déclare un espace de noms cible (targetNamespace) pour les éléments définis dans le
schéma.
• targetNamespace="http://www.example.com/soap/ws/loanEligibility" : L'URL fournie est l'espace de noms cible pour tous les éléments
définis dans ce schéma. Cela signifie que les éléments définis ici appartiennent à cet espace de noms.
• xmlns:tns="http://www.example.com/soap/ws/loanEligibility" : Déclare un préfixe (tns) qui est associé à l'espace de noms cible. Ce préfixe
est utilisé pour qualifier les éléments et types définis dans le schéma.
• elementFormDefault="qualified" : Indique que tous les éléments définis par ce schéma doivent être qualifiés avec le préfixe de l'espace de
noms (tns).
• <xsd:element name="CustomerRequest"> : Définit un élément complexe nommé CustomerRequest. Cet élément représente une demande de
client dans le contexte du service web.
• <xsd:complexType> : Indique que CustomerRequest est un type complexe, ce qui signifie qu'il peut contenir plusieurs éléments enfants.
• <xsd:sequence> : Spécifie que les éléments enfants doivent apparaître dans un ordre séquentiel strict dans le document XML.
• <xsd:element name="customerName" type="xsd:string" /> : Définit un
élément enfant de CustomerRequest qui est de type string.
• Les autres éléments (age, yearlyIncome, cibilScore, employmentMode) sont
définis de manière similaire avec des types appropriés (int, long, string).
• <xsd:element name="Acknowledgement"> : Définit un autre élément
complexe nommé Acknowledgement, qui représente la réponse du service web
indiquant si le client est éligible pour un prêt.
• <xsd:element name="isEligible" type="xsd:boolean" /> : Un élément enfant
qui indique si le client est éligible (true ou false).
• <xsd:element name="approvedAmount" type="xsd:long" /> : Un élément
enfant qui indique le montant du prêt approuvé.
• <xsd:element name="CriteriaMismatch" type="xsd:string"
maxOccurs="unbounded" /> : Un élément enfant qui peut apparaître plusieurs
fois (ou être "non borné") et qui contient des informations sur les critères non
satisfaits pour l'éligibilité au prêt.
Install Maven project
Generation du package loaneligibility
Endpoint package
Endpoint package
Endpoint package
package com.example.soap.ws.Endpoint;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;
import org.springframework.ws.server.endpoint.annotation.RequestPayload;
import org.springframework.ws.server.endpoint.annotation.ResponsePayload;
import com.example.soap.ws.loaneligibility.Acknowledgement;
import com.example.soap.ws.loaneligibility.CustomerRequest;
import com.example.soap.ws.Service.LoanEligibilityService;
@Endpoint
public class LoanEligibilityindicatorEndpoint {
private static final String NAMESPACE =
"http://www.example.com/soap/ws/loanEligibility";
@Autowired
private LoanEligibilityService service;
@PayloadRoot(namespace = NAMESPACE, localPart = "CustomerRequest")
@ResponsePayload
public Acknowledgement getLoanStatus(@RequestPayload CustomerRequest request) {
return service.checkLoanEligibility(request);
}
}
Ce code est un exemple d'un point de terminaison (endpoint) de service web SOAP en utilisant Spring Web
Services. Voici une explication détaillée :
- @Endpoint : Cette annotation marque la classe comme un point de terminaison de service web SOAP. Spring
détectera automatiquement cette classe pour le traitement des messages SOAP.
- LoanEligibilityindicatorEndpoint : C'est le nom de la classe Java qui est définie comme un point de
terminaison. Elle contient la logique pour traiter les requêtes SOAP entrantes.
- NAMESPACE: Une constante de chaîne qui définit l'espace de noms XML utilisé par ce point de terminaison.
Cela est utilisé pour associer les requêtes entrantes au bon point de terminaison.
- @Autowired : Cette annotation est utilisée pour l'injection automatique de dépendance dans Spring. Ici, elle
est utilisée pour injecter une instance de `LoanEligibilityService` dans le point de terminaison.
- LoanEligibilityService service : C'est le service métier qui contient la logique pour déterminer l'éligibilité à un prêt. Le point
de terminaison l'utilisera pour traiter les requêtes.
- @PayloadRoot : Cette annotation est utilisée pour spécifier le localPart (le nom de l'élément) et l'espace de noms du
message entrant que ce point de terminaison doit gérer.
- @ResponsePayload : Indique que la valeur de retour de la méthode doit être mappée au corps de la réponse SOAP.
- @RequestPayload : Indique que le paramètre de la méthode doit être mappé à partir du corps de la requête SOAP.
- getLoanStatus : C'est la méthode qui sera appelée lorsqu'un message SOAP avec un élément `CustomerRequest` dans le bon
espace de noms est reçu. Elle prend un `CustomerRequest` comme entrée et retourne un `Acknowledgement` comme
réponse.
- CustomerRequest : C'est une classe générée à partir du schéma XSD qui représente la structure de données de la requête
client.
- Acknowledgement : C'est une autre classe générée à partir du schéma XSD qui représente la structure de données de la
réponse du service.
Lorsque le service web reçoit un message SOAP avec un élément `CustomerRequest`, Spring Web Services route ce message
vers la méthode `getLoanStatus` de cette classe en raison de la correspondance de l'espace de noms et du localPart. La
méthode utilise ensuite `LoanEligibilityService` pour traiter la demande et renvoie un objet `Acknowledgement` qui est
sérialisé en XML et envoyé comme réponse SOAP au client.
Service package
package com.example.soap.ws.Service;
import java.util.List;
import org.springframework.stereotype.Service;
import com.example.soap.ws.loaneligibility.Acknowledgement;
import com.example.soap.ws.loaneligibility.CustomerRequest;
@Service
public class LoanEligibilityService {
public Acknowledgement checkLoanEligibility(CustomerRequest request) {
Acknowledgement acknowledgement = new Acknowledgement();
List<String> mismatchCriteriaList = acknowledgement.getCriteriaMismatch();
if (!(request.getAge() > 30 && request.getAge() <= 60)) {
mismatchCriteriaList.add("Person age should in between 30 to 60");
}
if (!(request.getYearlyIncome() > 200000)) {
mismatchCriteriaList.add("minimum income should be more than 200000");
}
if (!(request.getCibilScore() > 500)) {
mismatchCriteriaList.add("Low CIBIL Score please try after 6 month");
}
if (mismatchCriteriaList.size() > 0) {
acknowledgement.setApprovedAmount(0);
acknowledgement.setIsEligible(false);
} else {
acknowledgement.setApprovedAmount(500000);
acknowledgement.setIsEligible(true);
mismatchCriteriaList.clear();
}
return acknowledgement;
}
Ce code définit un service Spring, `LoanEligibilityService`, qui est utilisé pour évaluer
l'éligibilité d'un client à un prêt en fonction de certaines règles métier. Voici une
explication de ce que fait le service :
- @Service : Cette annotation marque la classe comme un bean de service dans le
contexte de l'application Spring, ce qui la rend éligible pour l'injection de dépendance et
la gestion transactionnelle, entre autres aspects de l'infrastructure Spring.
- checkLoanEligibility(CustomerRequest request): C'est une méthode publique qui
prend une `CustomerRequest` en paramètre et retourne un objet `Acknowledgement`.
Cette méthode est le cœur de la logique métier pour déterminer si un client est éligible à
un prêt.
- Acknowledgement acknowledgement = new Acknowledgement(); : Crée une nouvelle
instance de `Acknowledgement`, qui sera utilisée pour stocker et retourner le résultat de
l'évaluation de l'éligibilité.
- List<String> mismatchCriteriaList = acknowledgement.getCriteriaMismatch(); :
Récupère la liste des critères non satisfaits à partir de l'objet `Acknowledgement`.
- Les conditions `if` vérifient si le client répond à trois critères spécifiques : l'âge doit être entre
30 et 60 ans, le revenu annuel doit être supérieur à 200 000, et le score CIBIL doit être supérieur à
500. Si l'une de ces conditions n'est pas remplie, un message correspondant est ajouté à
`mismatchCriteriaList`.
- Si mismatchCriteriaList contient au moins un élément après l'évaluation des critères, cela signifie
que le client n'a pas satisfait à au moins un des critères d'éligibilité. Dans ce cas,
acknowledgement est mis à jour pour indiquer que le client n'est pas éligible (`setIsEligible(false)`)
et le montant approuvé est défini à 0.
- Si aucun critère de non-conformité n'est trouvé, cela signifie que le client répond à tous les
critères d'éligibilité. L'objet `acknowledgement` est alors mis à jour pour refléter que le client est
éligible (`setIsEligible(true)`) et un montant approuvé de 500 000 est défini.
- Finalement, l'objet Acknowledgement est retourné, contenant le résultat de l'évaluation de
l'éligibilité, le montant approuvé et la liste des critères non satisfaits si applicable.
Ce service est utilisé pour évaluer si un client est éligible à un prêt en fonction de son âge, de son
revenu annuel et de son score CIBIL. Il retourne un objet `Acknowledgement` qui indique si le prêt
est approuvé ou non, avec le montant approuvé et les raisons d'une éventuelle non-éligibilité.
Config package
Config package
Config package
package com.example.soap.ws.Config;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.ws.config.annotation.EnableWs;
import org.springframework.ws.transport.http.MessageDispatcherServlet;
import org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition;
import org.springframework.xml.xsd.SimpleXsdSchema;
import org.springframework.xml.xsd.XsdSchema;
@Configuration
@EnableWs
public class SoapWSConfig {
@Bean
public ServletRegistrationBean<MessageDispatcherServlet> messageDispatcherServlet(ApplicationContext context) {
MessageDispatcherServlet servlet = new MessageDispatcherServlet();
servlet.setApplicationContext(context);
servlet.setTransformWsdlLocations(true);
return new ServletRegistrationBean<MessageDispatcherServlet>(servlet, "/ws/*");
}
@Bean(name = "loanEligibility")
public DefaultWsdl11Definition defaultWsdl11Definition(XsdSchema schema) {
DefaultWsdl11Definition defaultWsdl11Definition = new DefaultWsdl11Definition();
defaultWsdl11Definition.setPortTypeName("LoanEligibilityindicator");
defaultWsdl11Definition.setLocationUri("/ws");
defaultWsdl11Definition.setTargetNamespace("http://www.example.com/soap/ws/loanEligibility");
defaultWsdl11Definition.setSchema(schema);
return defaultWsdl11Definition;
@Bean
public XsdSchema schema() {
return new SimpleXsdSchema(new ClassPathResource("loaneligibility.xsd"));
}
}
Ce code est une configuration Spring pour un service web SOAP. Il définit les beans nécessaires pour configurer
l'infrastructure de Spring Web Services. Voici une explication des composants clés :
- @Configuration : Cette annotation indique que la classe est une source de définitions de beans pour le contexte
d'application Spring.
- @EnableWs : Active les fonctionnalités liées aux services web SOAP dans l'application Spring.
- SoapWSConfig : Le nom de la classe de configuration.
- messageDispatcherServlet(ApplicationContext context) : Définit un bean pour le `ServletRegistrationBean` qui enregistre
le `MessageDispatcherServlet` de Spring Web Services. Ce servlet agit comme un frontal pour les requêtes SOAP entrantes.
- MessageDispatcherServlet : Est configuré avec le contexte d'application Spring et est responsable de la gestion des
requêtes SOAP.
- setTransformWsdlLocations(true) : Indique au servlet de transformer les adresses des WSDL en fonction de l'adresse à
laquelle le client a accédé au service.
- new ServletRegistrationBean<MessageDispatcherServlet>(servlet, "/ws/*") : Enregistre le servlet pour qu'il réponde aux
requêtes sur le chemin `/ws/*`.
- defaultWsdl11Definition(XsdSchema schema) : Définit un bean pour
`DefaultWsdl11Definition` qui est utilisé pour générer un WSDL 1.1 à partir d'un schéma XSD.
- setPortTypeName("LoanEligibilityindicator") : Définit le nom du portType dans le WSDL.
- setLocationUri("/ws") : Définit l'URI où le service sera disponible.
- setTargetNamespace("http://www.example.com/soap/ws/loanEligibility") : Définit
l'espace de noms cible pour le WSDL.
- setSchema(schema) : Associe le schéma XSD au WSDL pour la définition des types.
- schema() : Définit un bean pour le schéma XSD qui sera utilisé pour générer le WSDL.
`SimpleXsdSchema` est utilisé pour charger un schéma XSD, ici `loaneligibility.xsd`, qui se trouve
dans le classpath de l'application.
Cette configuration crée l'infrastructure nécessaire pour exposer un service web SOAP à l'URI
`/ws` avec un WSDL généré à partir du schéma XSD spécifié. Le WSDL généré sera utilisé par les
clients pour comprendre comment interagir avec le service, y compris les opérations
disponibles, les messages de requête et de réponse, et les détails de transport.
Run application
Run application
Test WebService
Install SoapUI
Maintenant, nous avons réussi à implémenter et tester un WS en SOAP
et Spring Boot.
Deuxième partie : Consommer notre WS
Créer le fichier loanEgibility.wsdl
• Nous allons recuperer le contenu de notre fichier a partir du WS
producer : http://localhost:8080/ws/loanEligibility.wsdl
Modifier le fichier pom.xml
Ajouter le plugin suivant :
<plugin>
<groupId>org.jvnet.jaxb2.maven2</groupId>
<artifactId>maven-jaxb2-plugin</artifactId>
<version>0.14.0</version>
<executions>
<execution>
<goals>
<goal>generate</goal>
</goals>
</execution>
</executions>
<configuration>
<schemaLanguage>WSDL</schemaLanguage>
<generatePackage>com.example.consume.soap.stub</generatePackage>
<generateDirectory>${project.basedir}/src/main/java</generateDirectory>
<schemaDirectory>${project.basedir}/src/main/resources/wsdl</schemaDirectory>
<schemaIncludes>
<include>*.wsdl</include>
</schemaIncludes>
</configuration>
</plugin>
Explication
Ce morceau de code est une configuration pour le `maven-jaxb2-plugin` dans un fichier `pom.xml` de Maven. Ce
plugin est utilisé pour générer des classes Java à partir de schémas XML ou de fichiers WSDL (Web Services
Description Language). Voici une explication de chaque partie de la configuration :
- <groupId>org.jvnet.jaxb2.maven2</groupId> : Identifie le groupe qui a publié le plugin, qui est
`org.jvnet.jaxb2.maven2` dans ce cas.
- <artifactId>maven-jaxb2-plugin</artifactId>: Le nom du plugin, qui est `maven-jaxb2-plugin`.
- <version>0.14.0</version>: La version du plugin à utiliser.
- <executions>: Cette section définit quand et comment le plugin doit être exécuté.
- <execution> : Une instance d'exécution du plugin.
- <goals> : Définit les objectifs (goals) spécifiques du plugin à exécuter.
- <goal>generate</goal> : L'objectif ici est `generate`, ce qui signifie que le plugin générera des fichiers sources lors de son exécution.
- <configuration>: Contient les paramètres de configuration pour le plugin.
- <schemaLanguage>WSDL</schemaLanguage>: Indique que le langage du schéma source est WSDL, ce qui signifie que le plugin s'attend à
traiter des fichiers WSDL pour la génération de code.
- <generatePackage>com.example.consume.soap.stub</generatePackage> : Le package Java dans lequel les classes générées seront placées.
- <generateDirectory>${project.basedir}/src/main/java</generateDirectory> : Le répertoire où les fichiers générés seront placés, qui est le
répertoire standard pour le code source Java dans un projet Maven.
- <schemaDirectory>${project.basedir}/src/main/resources/wsdl</schemaDirectory> : Le répertoire où se trouvent les fichiers WSDL à
partir desquels générer les classes Java.
- <schemaIncludes>: Spécifie les schémas à inclure dans la génération.
- <include>*.wsdl</include>: Inclut tous les fichiers avec l'extension `.wsdl` situés dans le `schemaDirectory` spécifié pour la génération.
Ce plugin est configuré pour générer des classes Java dans le package `com.example.consume.soap.stub` à partir de tous les fichiers `.wsdl`
trouvés dans le répertoire `src/main/resources/wsdl` du projet. Les classes générées seront placées dans le répertoire `src/main/java`. Cela est
souvent utilisé pour créer des stubs ou des proxies pour consommer des services web SOAP dans une application Java.
Generation des fichiers java
Erreur suceptible
• En cas d’erreur : il faut changer javax.xml par jakarta.xml
SoapClient.java
package com.example.soap.ws;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import org.springframework.stereotype.Service;
import org.springframework.ws.client.core.WebServiceTemplate;
import com.example.soap.ws.stub.Acknowledgement;
import com.example.soap.ws.stub.CustomerRequest;
@Service
public class SoapClient {
@Autowired
private Jaxb2Marshaller marshaller;
private WebServiceTemplate template;
public Acknowledgement getLoanStatus(CustomerRequest request) {
template = new WebServiceTemplate(marshaller);
Acknowledgement acknowledgement = (Acknowledgement)
template.marshalSendAndReceive("http://localhost:8080/ws",
request);
return acknowledgement;
}
}
Le code fourni agit comme un client SOAP dans une application Spring:
- @Service : Cette annotation marque la classe comme un bean de service dans le contexte de l'application Spring, ce
qui la rend éligible pour l'injection de dépendance et la gestion par le conteneur Spring.
- SoapClient : C'est le nom de la classe qui est définie comme un service Spring. Elle contient la logique pour
communiquer avec un service web SOAP.
- @Autowired : Cette annotation est utilisée pour l'injection automatique de dépendance dans Spring. Ici, elle est
utilisée pour injecter une instance de `Jaxb2Marshaller` dans le client SOAP.
- Jaxb2Marshaller marshaller : C'est un marshaller JAXB2 qui est utilisé pour convertir les objets Java en XML et
inversement pour les requêtes et réponses SOAP.
- WebServiceTemplate template : C'est un outil fourni par Spring pour envoyer des requêtes SOAP.
- getLoanStatus(CustomerRequest request) : C'est une méthode publique qui prend une `CustomerRequest` en
paramètre et retourne un objet `Acknowledgement`. Cette méthode est utilisée pour envoyer la demande au service
web SOAP et recevoir la réponse.
- template = new WebServiceTemplate(marshaller) : Cette ligne initialise
`WebServiceTemplate` avec le marshaller configuré pour la sérialisation et la
désérialisation des messages SOAP.
- template.marshalSendAndReceive("http://localhost:8080/ws", request) : Cette
ligne envoie la requête SOAP à l'URL spécifiée et attend la réponse. L'URL est
l'endpoint du service web SOAP auquel le client veut se connecter. Dans ce cas, il
s'agit d'un service local tournant sur le port 8080.
- Acknowledgement acknowledgement = (Acknowledgement) ... : La réponse
reçue est castée (convertie) en un objet `Acknowledgement`, qui est une classe
générée à partir du WSDL du service web et qui représente la réponse du service.
Cette classe est un client SOAP qui utilise `WebServiceTemplate` pour envoyer une
demande de prêt encapsulée dans un objet `CustomerRequest` à un service web et
pour recevoir une réponse sous forme d'un objet `Acknowledgement`. Cela permet
à l'application Spring d'interagir avec des services web externes en utilisant le
protocole SOAP.
SoapConfig.java
package com.example.soap.ws;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
@Configuration
public class SoapConfig {
@Bean
public Jaxb2Marshaller marshaller() {
Jaxb2Marshaller marshaller=new Jaxb2Marshaller();
marshaller.setPackagesToScan("com.example.soap.ws.stub");
return marshaller;
}
}
C’est une classe de configuration Spring qui définit un bean JAXB2
Marshaller. Voici une explication détaillée :
• @Configuration : Cette annotation indique que la classe est utilisée
par Spring comme source de définitions de beans. Spring va traiter
cette classe pour générer des beans à partir des méthodes annotées
avec @Bean.
• SoapConfig : Le nom de la classe de configuration.
• @Bean : L'annotation @Bean est utilisée sur une méthode pour
indiquer que la méthode va retourner un objet qui doit être
enregistré comme un bean dans le contexte d'application de Spring.
Le nom de la méthode (marshaller) est généralement utilisé comme
l'identifiant du bean dans le conteneur Spring.
• public Jaxb2Marshaller marshaller() : La méthode marshaller est
déclarée publique et retourne une instance de Jaxb2Marshaller. C'est
la méthode qui crée le bean.
• Jaxb2Marshaller marshaller = new Jaxb2Marshaller(); : Cette ligne crée
une nouvelle instance de Jaxb2Marshaller, qui est une classe de Spring
Framework utilisée pour lier des objets Java à leur représentation XML et
vice versa.
• marshaller.setPackagesToScan("com.example.soap.ws.stub"); : Cette ligne
configure le Jaxb2Marshaller pour qu'il scanne le package spécifié à la
recherche de classes annotées avec des annotations JAXB, telles que
@XmlRootElement. Ces classes sont utilisées pour générer ou interpréter
des messages XML lors des appels de service web SOAP.
• return marshaller; : La méthode retourne l'instance configurée de
Jaxb2Marshaller.
Cette configuration définit un bean Jaxb2Marshaller qui est configuré pour
scanner un package spécifique pour les classes JAXB. Ce marshaller peut
ensuite être injecté dans d'autres composants Spring, comme des clients de
services web SOAP, pour la sérialisation et la désérialisation des objets Java
en XML et inversement lors des appels de service web.
Modifier SpringBootSoapWsClient1Application.java
package com.example.soap.ws;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.example.soap.ws.SoapClient;
import com.example.soap.ws.stub.Acknowledgement;
import com.example.soap.ws.stub.CustomerRequest;
@SpringBootApplication
@RestController
public class SpringBootSoapWsClient1Application {
@Autowired
private SoapClient client;
@PostMapping("/getLoanStatus")
public Acknowledgement invokeSoapClientToGetLoanStatus(@RequestBody CustomerRequest request) {
return client.getLoanStatus(request);
}
public static void main(String[] args) {
SpringApplication.run(SpringBootSoapWsClient1Application.class, args);
}
C’est une application Spring Boot qui agit comme un client pour un service
web SOAP. Voici une explication détaillée de ses composants :
• @SpringBootApplication : Cette annotation est utilisée pour marquer la
classe principale d'une application Spring Boot. Elle englobe les
annotations @Configuration, @EnableAutoConfiguration, et
@ComponentScan.
• @RestController : Cette annotation est utilisée pour définir une classe de
contrôleur dans Spring MVC. Elle indique que la classe va être un bean
contrôleur et que les méthodes retournent des réponses pour les requêtes
web.
• SpringBootSoapWsClient1Application : C'est le nom de la classe principale
qui démarre l'application Spring Boot.
• @Autowired : Cette annotation est utilisée pour l'injection automatique de
dépendance. Ici, elle injecte une instance de SoapClient dans la classe
contrôleur.
• private SoapClient client; : C'est une déclaration de variable pour le client
SOAP qui sera utilisé pour envoyer des requêtes au service web SOAP.
• @PostMapping("/getLoanStatus") : Cette annotation définit une méthode de
contrôleur qui gère les requêtes POST à l'URI /getLoanStatus.
• public Acknowledgement invokeSoapClientToGetLoanStatus(@RequestBody
CustomerRequest request) : Cette méthode est appelée lorsqu'une requête POST est
reçue sur /getLoanStatus. Elle prend un CustomerRequest comme corps de la requête,
qui est automatiquement désérialisé à partir du JSON reçu.
• return clinet.getLoanStatus(request); : La méthode appelle getLoanStatus sur
l'instance SoapClient injectée, en passant la CustomerRequest reçue, et retourne
l'Acknowledgement reçu du service web SOAP.
• public static void main(String[] args) : C'est le point d'entrée de l'application Java. La
méthode main utilise SpringApplication.run pour démarrer l'application Spring Boot.
• SpringApplication.run(ConsumesoapWsApplication.class, args); : Cette ligne
démarre l'application Spring Boot en utilisant la classe ConsumesoapWsApplication
comme source de configuration.
Cette application Spring Boot expose un endpoint REST /getLoanStatus qui, lorsqu'il est
appelé via une requête POST avec un CustomerRequest en JSON, utilise un client SOAP
pour communiquer avec un service web SOAP externe, récupère la réponse sous forme
d'un objet Acknowledgement, et renvoie cette réponse au client appelant.
Erreur suceptible
Configurer le port pour le Consumer du WS
Test application avec Postman
Resultat
