Webservice java avec CXF et Spring

TheBigJim

Toujours avec le même leitmotiv « Droit à l'Essentiel », nous allons créer un service web en java en utilisant CXF et Spring. L'idée est que cet article permette d'être autonome en très peu de temps. Le déploiement du service web qui sera créé sera déployé en local.

- Titre : Webservice java avec CXF et Spring

- Auteur : TheBigJim

- Parution : 18 janvier 2011

- Mise à jour : 23 février 2020

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2011 TheBigJim. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Prérequis

- II. Webservice, un peu de vocabulaire

- II-A. Webservice, c'est quoi ?

- II-B. CXF c'est quoi ?

- II-C. SOAP c'est quoi ?

- III. Création du webservice

- III-A. Architecture de notre projet

- III-B. Maven, le fichier pom.xml

- III-C. Le pom.xml dans son intégralité

- IV. Le développement

- IV-A. Les packages

- IV-B. Le service à proprement parler

- IV-C. Le code de l'interface

- IV-D. Le code de l'interface

- V. Configuration Spring et CXF au sein du projet

- VI. Configuration du service web sous Spring

- VII. Compilation et déploiement

- VII-A. Compilation

- VII-B. Déploiement

- VII-C. Vérification du déploiement

- VIII. Conclusion

I - Prérequis

- Java.

- Eclipse (un minimum de connaissance sur eclipse).

- Spring (connaissance non obligatoire).

- Maven installé et configuré.

- Tomcat installé et configuré.

II - Webservice, un peu de vocabulaire

II-A - Webservice, c'est quoi ?

C'est une application (utilisant le protocole http) dont on peut invoquer diverses fonctionnalités ou opérations à distance (par réseau). Le réseau peut être public (Internet) ou privé (intranet), le service web peut aussi intégrer des mécanismes de sécurité permettant de privatiser son accès sur un réseau public.

II-B - CXF c'est quoi ?

CXF est un projet open source de la fondation Apache. Ce framework permet de développer aisément des services web SOAP grâce à l'API JAX-WS ou REST grâce à l'API JAX-RS. Cet article s'arrêtera à l'utilisation de JAX-WS, JAX-RS et REST feront l'objet d'un prochain article.

II-C - SOAP c'est quoi ?

Simple Object Access Protocol, protocole d'accès aux objets simples. Comme son nom ne l'indique pas, c'est un protocole d'échange d'informations interapplication basé sur xml.

III - Création du webservice

III-A - Architecture de notre projet

Il s'agit ici de créer un service web donc disponible via le protocole http. De ce fait, le projet à créer est un projet de type web, et le livrable sera un fichier war à déployer sous Tomcat.

L'utilisation de maven impose l'organisation des dossiers du projet web. Pour rappel :

- src/main/java : répertoire des classes java ;

- src/main/webapp: répertoire de la webapp qui va héberger le webservice ;

- src/test/java : répertoire des classes de test.

III-B - Maven, le fichier pom.xml

Les dépendances Spring et CXF à déclarer dans le pom.xml.

pom.xml

<dependencies>
<dependency>
<groupId>springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.6</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-core</artifactId>
<version>2.2.10</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-bundle</artifactId>
<version>2.2.10</version>
</dependency>
</dependencies>

III-C - Le pom.xml dans son intégralité

pom.xml

<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>WSAuthentication</groupId>
<artifactId>WSAuthentication</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.6</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-core</artifactId>
<version>2.1</version>
</dependency>
</dependencies>
</project>

Dans ce fichier, il est indiqué :

- la forme du livrable (war en section packaging) ;

- la version de la jvm source à partir de laquelle est développé le service ;

- la version de la jvm cible sur laquelle le service web est censé fonctionner (section build). Modifier la version du target build en fonction de la version jvm sous laquelle tourne votre Tomcat.

IV - Le développement

IV-A - Les packages

Après avoir créé le projet Java (appelons-le WSAuthentication) sous Eclipse, créez deux packages distincts :

- wsinterface qui comportera l'interface (la description) de notre service web ;

- wsimplementation qui en sera l'implémentation.

Sous Eclipse, faites un clic droit sur votre projet, puis New/Package comme suit :

Indiquez le nom du package (wsinterface), puis cliquez sur le bouton « Finish »

Répétez l'opération pour le package wsimplementation.

IV-B - Le service à proprement parler

Le service est très simple. Pour l'exemple, il s'agit d'implémenter une authentification qui, à partir d'un identifiant et un mot de passe, avalise ou non un accès.

La première chose à faire est d'écrire l'interface qui décrit le service : la signature de la classe qui implémentera l'interface du service web. Appelons cette interface « AuthenticationService ». Enfin, il faut écrire la signature de la méthode qui sera invoquée pour avaliser ou non l'accès. Appelons cette méthode « getAccess » qui prend en paramètre un identifiant et un mot de passe.

IV-C - Le code de l'interface

interface

package wsinterface;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;

@WebService
public interface AuthenticationService {

@WebMethod
public Boolean getAccess(
@WebParam(name="login") String login,
@WebParam(name="password") String password);
}

Dans l'exemple ci-dessus, les annotations :

- « @WebService » indique que notre classe est un service web ;

- « @WebMethod » indique que la méthode sera exposée aux clients lors du déploiement ;

- « @WebParam » indique que le paramètre est une information donnée par le client, l'invocation du service nécessite (exigence) tous les WebParam indiqués, cependant cette annotation, bien que fortement recommandée, n'est pas obligatoire. En effet, sans cette annotation vos paramètres porteront de doux noms tels que argN, ce qui peut en rendre la lecture et/ou la compréhension chaotique.

Une fois l'interface créée, celle-ci peut être implémentée afin d'écrire dans le détail ce que va faire le service web pour répondre au besoin. L'implémentation très simple, va consister ici à répondre positivement pour un couple (identifiant, mot de passe) particulier (tarzan, jane).

IV-D - Le code de l'interface

implémentation

package wsimplementation;

import javax.jws.WebService;
import wsinterface.AuthenticationService;

@WebService(
endpointInterface = "wsinterface.AuthenticationService",
serviceName = "authenticationService")
public class AuthenticationServiceImpl implements AuthenticationService {

public Boolean getAccess(String login, String password) {
if ( login.equals("tarzan") && password.equals("jane")) {
return Boolean.TRUE;
}

return Boolean.FALSE;
}
}

Dans l'exemple ci-dessus, l'annotation « @WebService » utilise les paramètres :

- endpointInterface pour indiquer l'interface qui est implémentée ;

- serviceName pour indiquer le nom du service exposé.

V - Configuration Spring et CXF au sein du projet

Pour intégrer Spring au projet web, il suffit d'ajouter au fichier web.xml les clauses suivantes :

web.xml

<context-param>
<!-- La localisation du fichier applicationContext.xml -->
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/applicationContext.xml</param-value>
</context-param>
<!-- Le listener Spring qui va charger le fichier applicationContext.xml -->
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

Même chose pour CXF, il suffit d'ajouter les clauses suivantes (indiquant entre autres via url-pattern, la forme de l'url qui permettra d'accéder au service web [/ws/methodeAppellée]) au fichier web.xml :

<!-- Configuration de CXF -->
<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>/ws/*</url-pattern>
</servlet-mapping>

VI - Configuration du service web sous Spring

Pour pouvoir configurer des services web CXF depuis Spring, ajouter les directives suivantes au fichier « applicationContext.xml » :

<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" />

Pour configurer et déclarer le service web créé préalablement, il suffit d'ajouter dans ce même fichier une directive jaxws:endpoint comme suit, dans laquelle on indique la classe d'implémentation du service web ainsi que l'url qui nous permettra d'y accéder :

<jaxws:endpoint id="authentication"
implementor="wsimplementation.AuthenticationServiceImpl"
address="/authentication">
</jaxws:endpoint>

VII - Compilation et déploiement

VII-A - Compilation

Une simple commande maven va permettre de générer un livrable à déployer sous Tomcat, se placer dans le dossier du projet et lancer la commande suivante : mvn clean install. Le livrable sous forme d'un fichier war devrait se trouver dans le dossier target du projet web.

VII-B - Déploiement

L'opération est simple ici aussi, soit vous déposez le fichier directement dans le dossier Tomcat adéquat, soit vous passez par le manager (interface web de Tomcat).

VII-C - Vérification du déploiement

Depuis un browser, tapez l'url du webservice : http://localhost:8080/WSAuthentication-0.0.1-SNAPSHOT/ws/ Devrait apparaitre une page web listant toutes les méthodes publiques du webservice.

VIII - Conclusion

J'espère avoir été clair dans mon propos. Il nous reste maintenant à montrer comment invoquer le service web créé, objet d'un prochain article.