2A ISITD 2022/2023

TP1 : Réalisation d’un Web Service SOAP

Durée: 4h

I. Test d’un Web service existant:

Télécharger SOAP UI Open Source depuis https://www.soapui.org/downloads/soapui/
En utilisant votre navigateur, Ouvrir la WSDL suivante :
http://www.dneonline.com/calculator.asmx?wsdl et analysez la qu’est ce que à votre avis
que fournis le service web?

Sélectionnez l'option «Nouveau projet SOAP» dans le menu Fichier, ce qui affichera la boîte
de dialogue suivante:

Collez le chemin WSDL http://www.dneonline.com/calculator.asmx?wsdl dans le champ

WSDL initial (le nom du projet en sera extrait) et appuyez sur OK.

SoapUI créera le projet avec le WSDL importé disponible dans le navigateur. Accédez
directement à la première requête «Request 1» générée pour l' opération d' ajout et double-
cliquez dessus, ce qui ouvre la fenêtre suivante:

1
2A ISITD 2022/2023

Il ne vous reste plus qu'à entrer deux valeurs entières et à appuyer sur la flèche verte en haut à
gauche pour soumettre la demande au service cible, qui vous renverra la réponse. Essayez de
visualiser la réponse sous fomat XML au lieu du RAW pour faciliter sa lecture.

II. Réalisation d’un Web service SOAP:

1. Préparation du TP :
Télécharger Spring Tool depuis https://spring.io/tools
Créer un nouveau projet « Import Spring Getting Started Content »

Dans la barre de recherche écrire SOAP et choisir « producing web service », et décochez
l’option complete en dessous comme dans la figure suivante :

2
2A ISITD 2022/2023

Laisser charger les dépendances de spring Boot, cette opération peut prendre quelques
minutes.
2. Ajouter la dépendance Spring-WS
Le projet doit inclure spring-ws-core et en wsdl4j tant que dépendances dans votre fichier de
construction. Le code suivant montre la configuration des plugins nécessaires pour Maven
dans le fichier POM.XML
<?xml version="1.0" encoding="UTF-8"?>
<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
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.1</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>producing-web-service-complete</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>producing-web-service-complete</name>
<description>Demo project for Spring Boot</description>

<properties>

3
2A ISITD 2022/2023

<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web-services</artifactId>
</dependency>
<!-- tag::springws[] -->
<dependency>
<groupId>wsdl4j</groupId>
<artifactId>wsdl4j</artifactId>
</dependency>
<!-- end::springws[] -->

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<profiles>
<profile>
<id>java11</id>
<activation>
<jdk>[11,)</jdk>
</activation>

<dependencies>
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
</dependency>
</dependencies>
</profile>
</profiles>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- tag::xsd[] -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>jaxb2-maven-plugin</artifactId>
<version>2.5.0</version>
<executions>
<execution>
<id>xjc</id>
<goals>
<goal>xjc</goal>
</goals>
</execution>
</executions>
<configuration>

4
2A ISITD 2022/2023

<sources>

<source>${project.basedir}/src/main/resources/countries.xsd</source>
</sources>
</configuration>
</plugin>
<!-- end::xsd[] -->
</plugins>
</build>

</project>

3. Créer un schéma XML pour définir le domaine

Le domaine de service Web est défini dans un fichier de schéma XML (XSD) que Spring-WS
exportera automatiquement en tant que WSDL.
Créez un fichier XSD nomé countries.xsd (schéma XML) dans de src/main/resources/ avec
des opérations pour retourner un pays de name, population, capital et currency.

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://spring.io/guides/gs-producing-web-service"
targetNamespace="http://spring.io/guides/gs-producing-web-service"
elementFormDefault="qualified">

<xs:element name="getCountryRequest">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>

<xs:element name="getCountryResponse">
<xs:complexType>
<xs:sequence>
<xs:element name="country" type="tns:country"/>
</xs:sequence>
</xs:complexType>
</xs:element>

<xs:complexType name="country">
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="population" type="xs:int"/>
<xs:element name="capital" type="xs:string"/>
<xs:element name="currency" type="tns:currency"/>
</xs:sequence>

5
2A ISITD 2022/2023

</xs:complexType>

<xs:simpleType name="currency">
<xs:restriction base="xs:string">
<xs:enumeration value="GBP"/>
<xs:enumeration value="EUR"/>
<xs:enumeration value="PLN"/>
</xs:restriction>
</xs:simpleType>
</xs:schema>

4. Créer un référentiel de pays

Afin de fournir des données au service Web, créez un référentiel de pays. Dans ce guide,
vous créez une implémentation de référentiel de pays avec leurs données.
La classe CountryRepository.java qui doit être créée dans
src/main/java/com/example/producingwebservice/ doit contenir le code suivant :

package com.example.producingwebservice;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

import io.spring.guides.gs_producing_web_service.Country;
import io.spring.guides.gs_producing_web_service.Currency;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

@Component
public class CountryRepository {
private static final Map<String, Country> countries = new HashMap<>();

@PostConstruct
public void initData() {
Country spain = new Country();
spain.setName("Spain");
spain.setCapital("Madrid");
spain.setCurrency(Currency.EUR);
spain.setPopulation(46704314);

countries.put(spain.getName(), spain);

Country poland = new Country();

poland.setName("Poland");

6
2A ISITD 2022/2023

poland.setCapital("Warsaw");
poland.setCurrency(Currency.PLN);
poland.setPopulation(38186860);

countries.put(poland.getName(), poland);

Country uk = new Country();

uk.setName("United Kingdom");
uk.setCapital("London");
uk.setCurrency(Currency.GBP);
uk.setPopulation(63705000);

countries.put(uk.getName(), uk);
}

public Country findCountry(String name) {

Assert.notNull(name, "The country's name must not be null");
return countries.get(name);
}
}

5. Créer un point de terminaison de service de pays

Pour créer un point de terminaison de service, vous n'avez besoin que d'un POJO avec
quelques annotations Spring WS pour gérer les demandes SOAP entrantes. Créez La classe
CountryEndpoint.java située dans src/main/java/com/example/producingwebservice/ avec
le code suivant :

package com.example.producingwebservice;

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 io.spring.guides.gs_producing_web_service.GetCountryRequest;
import io.spring.guides.gs_producing_web_service.GetCountryResponse;

@Endpoint
public class CountryEndpoint {
private static final String NAMESPACE_URI = "http://spring.io/guides/gs-producing-
web-service";

private CountryRepository countryRepository;

7
2A ISITD 2022/2023

@Autowired
public CountryEndpoint(CountryRepository countryRepository) {
this.countryRepository = countryRepository;
}

@PayloadRoot(namespace = NAMESPACE_URI, localPart = "getCountryRequest")

@ResponsePayload
public GetCountryResponse getCountry(@RequestPayload GetCountryRequest
request) {
GetCountryResponse response = new GetCountryResponse();
response.setCountry(countryRepository.findCountry(request.getName()));

return response;
}
}

6. Configurer les beans de service Web

Créez une nouvelle classe WebServiceConfig.java dans
src/main/java/com/example/producingwebservice/ avec la configuration des beans liés à
Spring WS avec le code suivant :

package com.example.producingwebservice;

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.config.annotation.WsConfigurerAdapter;
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;

@EnableWs
@Configuration
public class WebServiceConfig extends WsConfigurerAdapter {
@Bean
public ServletRegistrationBean<MessageDispatcherServlet>
messageDispatcherServlet(ApplicationContext applicationContext) {
MessageDispatcherServlet servlet = new MessageDispatcherServlet();
servlet.setApplicationContext(applicationContext);

8
2A ISITD 2022/2023

servlet.setTransformWsdlLocations(true);
return new ServletRegistrationBean<>(servlet, "/ws/*");
}

@Bean(name = "countries")
public DefaultWsdl11Definition defaultWsdl11Definition(XsdSchema
countriesSchema) {
DefaultWsdl11Definition wsdl11Definition = new DefaultWsdl11Definition();
wsdl11Definition.setPortTypeName("CountriesPort");
wsdl11Definition.setLocationUri("/ws");
wsdl11Definition.setTargetNamespace("http://spring.io/guides/gs-producing-
web-service");
wsdl11Definition.setSchema(countriesSchema);
return wsdl11Definition;
}

@Bean
public XsdSchema countriesSchema() {
return new SimpleXsdSchema(new ClassPathResource("countries.xsd"));
}
}

7. Exécuter l’application
Cliquez droite sur l’application et run as : Spring Boot App.

III. Tester l’application

Ouvrir le lien http://localhost:8080/ws/countries.wsdl Qu’est-ce que vous pouvez conclure ?

Maintenant que l'application est en cours d'exécution, vous pouvez la tester. Créez un fichier
sur votre machine request.xml qui contient la requête SOAP suivante:

<soapenv:Envelope xmlns:soapenv=http://schemas.xmlsoap.org/soap/envelope/
xmlns:gs="http://spring.io/guides/gs-producing-web-service">
<soapenv:Header/>
<soapenv:Body>
<gs:getCountryRequest>
<gs:name>Spain</gs:name>
</gs:getCountryRequest>
</soapenv:Body>
</soapenv:Envelope>

Dans la ligne de commande CMD assurez-vous que vous pointez dans le répertoire ou vous
avez enregistré le fichier request.xml
Exemple : si votre fichier se trouve dans le chemin suivant C:/WebServices/TP il faut taper

9
2A ISITD 2022/2023

cd /D E:\WebServices\TP

Ensuite une fois vous pointer le répertoire contenant le fichier request.xml vous copiez la
commande suivante :

curl --header "content-type: text/xml" -d @request.xml http://localhost:8080/ws

Analysez la réponse SOAP reçue. Changer le fichier request.xml pour afficher les
informations d’autres pays.

III. Devoir Obligatoire !!

• Commenter les classes CountryEndpoint.java et WebServiceConfig.java en

précisant l’objectif de chaque annotation.
• Modifier le code pour ajouter aussi le Maroc parmi les pays et tester pour
afficher la réponse de votre Web service qui retourne les informations du
Maroc.
• Utiliser SOAP UI pour tester votre Web service SOAP.

10