Spring-Boot: Comment consommer un web-service Soap? Écrire un client web service par la pratique en 15 minutes

 

Nous allons présenter un guide pratique pour écrire un client java qui consomme un web service soap.

L'idée ici est de reprendre le guide de spring.io qui hélas s'appuie sur une url wsdl ne fonctionnant plus et qui rend le guide difficile à suivre.

Je propose ici d'utiliser l'url wsdl suivante: http://www.dneonline.com/calculator.asmx?wsdl

J'indique aussi la bonne version du plugin pour corriger une erreur de ce type:

Execution default of goal org.jvnet.jaxb2.maven2:maven-jaxb2-plugin:0.12.3:generate failed: A required class..

Services Web SOAP / REST

 Web Service

SOAP_REST

De plus en plus d'entreprises se tendent vers une architecture dont les données sont déportées des applications pour une meilleure distribution d'informations.
Cette approche permet de ne pas recréer les services de consommation de la base de données. Nombreux sont ceux qui rendent  leurs applications accessibles sur le web d'où l'appel à des Web Services.

Créer rapidement un webservice avec CXF

La communication via webservice est un procédé largement utilisé pour la communication inter-applicative.
CXF permet de rapidement mettre eb oeuvre un webservice ou de créer rapidement un client webservice.
Nous allons aborder la mise en oeuvre d'un webservice dans une application web gérée par SPRING dans la suite de cet article.
Un autre article décrira la génération automatique du code client d'un webservice.

Installation du projet Contacts

Pour ceux qui n'étaient pas à l'Ideo Bar (ouai j'ai les noms !! 🙂 ), j'y ai présenté une application Contacts qui permet de mettre en oeuvre une partie serveur en Java EE 6, avec du JPA, des EJB 3 et des web service rest JAX-RS.

Cette application est désormais disponible sur mon GitHub : https://github.com/sebrevel/Contacts

Vous y trouverez bien entendu le code mais aussi une petite explication : https://github.com/sebrevel/Contacts/blob/master/README.md

et une doc d'installation qui comprend le clone du repo GitHub, la création du workspace IntelliJ et le déploiement sur un Glassfish : http://www.youtube.com/watch?v=NJpBY6ys-mE&feature=plcp

Amusez-vous bien 🙂

Mise en place d’un WebService SOAP avec Apache CXF

Aujourd'hui pour mettre en place un webservice SOAP, il existe sur le marché différents frameworks: Axis, Spring WS et Apache CXF.

Si l'utilisation d'un framework comme Axis peut s'avérer assez fastidieuse, nous allons voir qu'avec Apache CXF, l'écriture de Webservices est très simplifiée.

Caractéristique

Le framework Apache CXF s'appuie sur la norme JAX-WS. Il supporte le mode "code-first", c'est-à-dire:  il autorise que le développeur commence par l'implémentation du webservice, avant la création du contrat d'interface.

Etude de cas

Nous allons implémenter un webservice qui va exposer un service d'addition. Il prendra en entrée 2 paramètres de type entier et retournera comme réponse la somme de ces 2 entiers.

Pré-Requis

Pour implémenter ce webservice, il faut être en moins en jdk 1.5.

Je vous conseille également d'utiliser maven pour récupérer les dépendances nécessaires.

Récupération des dépendances

Nous allons récupérer à l'aide de maven les librairies de cxf et de spring:

<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>2.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>2.2.3</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.5</version>
</dependency>

Implémentation

Nous allons déclarer l'interface de notre Webservice OperationService qui va contenir une méthode addition qui sera exposée:


package ideo.poc.cxf;
import javax.jws.WebMethod;
import javax.jws.WebService;
@WebService
public interface OperationService {
@WebMethod
public int addition (int a, int b);
}

Les annotations @WebService et @WebMethod permettent respectivement de spécifier que l'interface exposée sera l'interface OperationService et que la méthode exposée sera la méthode addition.

Cette interface sera implémentée par la classe OperationServiceImpl, de la façon suivante:


package ideo.poc.cxf;
public class OperationServiceImpl implements OperationService{
public int addition(int a, int b) {
return a + b;
}
}

Il est intéressant de noter qu'avec l'utilisation des annotations, notre interface et notre classe n'ont besoin d'aucune adhérence avec un framework tiers (aucun hétitage n'est nécessaire).

Configuration

Il reste à configurer 2 fichiers:

- le fichier applicationContext.xml utilisé par Spring (localisé dans le répertoire webapp/WEB-INF):

Il faut d'abord importer le context propre à CXF pour déployer le web service de la façon suivante:


<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

Puis il faut déclarer le "end-point", c'est-à-dire le point d'entrée de notre webservice. Dans notre cas il s'agira de la classe OperationServiceImpl:


<jaxws:endpoint id="oprationService"
implementor="ideo.poc.cxf.OperationServiceImpl"
address="/OperationService" />

- le fichier web.xml (localisé dans le répertoire webapp/WEB-INF) qui va notement déclarer une servlet provenant du framework CXF:


<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<display-name>democxf</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>CXFServlet</servlet-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>

Test du webservice

Une fois le war généré et déployé dans un serveur d'application, en tappant l'URL  http://localhost:8080/OperationService?wsdl, nous pouvons voir le WSDL généré:

Il ne nous reste plus qu'à tester notre webservice.

Dans un navigateur, en invoquant l'URL http://localhost:8080/OperationService/addition?arg0=1&arg1=2

Nous avons le résultat suivant:

Sources

Vous trouverez les sources de l'exemple ici .

Conclusion

Apache CXF est un framework qui permet d'écrire de façon très souple des Webservices SOAP par rapport à ces concurrents.

Si votre projet utilise Java 5, je vous conseille fortement ce framework pour le déploiement de Webservice.

JAX-RS web service REST avec Spring (implémentation RestEasy)

L'objet de ce billet: Illustrer avec un exemple assez complet la mise en pratique du web service REST (JAX-RS) s'appuyant sur l'implémentation RestEasy de JBoss avec Spring 2.5.
L'exemple repose sur les briques (api) suivantes. Notez bien la version lorsqu'elle est mentionnée.

  • RestEasy: L'implémentation Jboss de jax-rs (JSR 311),
  • Spring 2.5 et les annotations,
  • Hibernate pour la partie persistence
  • L'api Dozer v4.0 pour les DTO (Data Transfert Objetc) ou VO((Value Object).
  • Junit 4.4,
  • HttpUnit,
  • XMLUnit.

Nota:La version Dozer 4.0 a renommé complètement ses packages. Certains tutos sur le web sont donc caduques.
C'est à la fin de l'étape 5 que nous détaillons l'emploi de l'api Dozer.

Quelques repères:

REST (Representational State Transfer) développé par Roy Fielding qui est l’un des fondateurs du protocol HTTP.
JSR 311 est la spec JAX-RS: Java API for RESTful Web Service. Finalisée en mars 2008.

Les CINQ principes de REST

  • P1: Tout est ressource, un identifiant unique à chaque ressource (http://localhost:8888/clients/2 pointe sur le client ayant id=2),
  • P2: Utiliser les méthodes HTTP (HEAD/GET/POST/PUT/DELETE). Et les erreurs standards HTTP,
  • P3: Les échanges avec plusieurs représentations ( xml,(x)html, json,..),
  • P4: Échanges sans état (stateless),
  • P5: Lier les ressources entre elles.

PRÉ-REQUIS: Java5.