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.

Un commentaire

  1. Bonjour,
    Nous travaillons depuis quelques mois sur les échanges
    automatiques de données entre des bases de données relationnelles
    par exemple Oracle et MySQL.

    Les Webservices sont en environnement Java 1.6 implémentés avec la librairie CXF [protocoles SOAP, JAXWS, JAXB].

    Nous éprouvons des difficultés pour administrer au quotidien
    les échanges de données et en cas d’erreurs pour identifier rapidement l’origine d’un problème, poser un diagnostic et le corriger.

    Pourriez-vous nous donner quelques conseils sur ce dernier point.
    Merci beaucoup.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.