Webservice java avec CXF et Spring

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.

CXFCXF 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.

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.

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.

Les dépendances Spring et CXF à déclarer dans le 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>

<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.

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.

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.

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).

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é.

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.

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).

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.