Après l’article précédent « Webservice java avec CXF et Spring », il semblait naturel de passer à la partie cliente de notre service web.
Toujours en développement java, l’article va donc consister à créer un client de notre service web, toujours avec cxf, Spring et MAVEN2.

 

Prérequis

– Java
– Eclipse (un minimum de connaissance sur eclipse)
– Spring (non obligatoire)
– Maven installé et configuré
– Tomcat installé et configuré
– Avoir lu l’article « Webservice java avec CXF et Spring »
– Avoir déployé le webservice de l’article « Webservice java avec CXF et Spring »

 

Fichier WSDL, c’est quoi ?

WSDL est l’acronyme de webservice Description Language, langage de description de webservice. Un fichier WSDL n’est ni plus ni moins un fichier au format xml décrivant un service web.
Entre autres, ce fichier décrit le webservice ainsi que les méthodes publiques (avec leur signature) qu’il met à disposition de ses utilisateurs.

 
[s2If !is_user_logged_in() || current_user_is(s2member_level0)]

Pour lire la suite, devenez
abonné Premium de Faire des Jeux.
5€ seulement pour avoir accés à tous les articles pendant une année !


[s2Member-PayPal-Button level= »1″ ccaps= » » desc= »Abonné premium » ps= »paypal » lc= » » cc= »EUR » dg= »0″ ns= »1″ custom= »www.faire-des-jeux.com » ta= »0″ tp= »0″ tt= »D » ra= »5″ rp= »1″ rt= »Y » rr= »BN » rrt= » » rra= »1″ image= »http://www.video-game-codeur.fr/download/paypalbtn/btn_paypalxpressCheckout.gif » output= »button » /]

[/s2If]

[s2If current_user_can(access_s2member_level1)]
 

Méthode Contract First

L’idée principale de cette méthode est de décrire le webservice via un WSDL dans le but de s’affranchir de son implémentation, on spécifie le webservice sans en décrire l’implémentation ainsi on assure un découplage maximum entre conception et implémentation.

 

Méthode Implémentation First / Code First

L’idée principale de cette méthode est de développer un service web de A à Z, puis lors de son exposition, d’en générer dynamiquement le fichier WSDL.
Ceci, afin de rendre publique sa description. Aux utilisateurs du webservice, à partir du fichier WSDL de générer les classes sous-jacentes à l’utilisation dudit service. Cette approche est celle qui a été adoptée dans l’article « Webservice java avec CXF et Spring ».
Dans la continuité, nous allons donc générer les classes sous-jacentes à l’utilisation du webservice.

 

Prérequis à la création client

 

Architecture de notre projet

Dans cet exercice, il s’agit ici de configurer notre environnement pour nous permettre de créer le client du webservice. Entre autres, maven, dépendances, et génération des classes et interfaces.

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 classes générées à partir du fichier WSDL seront placées dans le package wsinterface pour les interfaces et dans le package wsimplementation pour les implémentations. Toutes ces informations sont issues du fichier WSDL.

 

Maven, le fichier pom.xml

Le fichier pom.xml doit comporter dans la section plugin le code suivant. Ce plugin va nous permettre d’invoquer la commande mvn generate-sources qui générera les classes nécessaires à l’invocation du service.
La balise sourceRoot (${basedir}/src/main/java/) indique au plugin le chemin de la racine des fichiers sources du projet.
La balise wsdl (${basedir}/src/main/resources/wsdl/authentication.wsdl) de wsdloption indique au plugin le chemin du fichier wdsl source de la génération des classes java.

<plugin>
  <groupId>org.apache.cxf</groupId>
  <artifactId>cxf-codegen-plugin</artifactId>
  <version>2.2.10</version>
  <executions>
    <execution>
      <id>generate-sources</id>
      <phase>generate-sources</phase>
      <configuration>
        <sourceRoot>${basedir}/src/main/java/</sourceRoot>
        <wsdlOptions>
          <wsdlOption>
            <wsdl>${basedir}/src/main/resources/wsdl/authentication.wsdl</wsdl>
          </wsdlOption>
        </wsdlOptions>
      </configuration>
      <goals>
        <goal>wsdl2java</goal>
      </goals>
    </execution>
  </executions>
</plugin>

 

Le pom.xml dans son intégralité

<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>WSAuthenticationClient</groupId>
  <artifactId>WSAuthenticationClient</artifactId>
  <version>0.0.1-SNAPSHOT!/version>
  <build>           
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>   
      <plugin>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-codegen-plugin</artifactId>
        <version>2.2.10</version>
        <executions>
          <execution>
            <id>generate-sources</id>
            <phase>generate-sources</phase>
            <configuration>
              <sourceRoot>${basedir}/src/main/java/</sourceRoot>
              <wsdlOptions>
                <wsdlOption>
                  <wsdl>${basedir}/src/main/resources/wsdl/authentication.wsdl&lt;/wsdl>
                </wsdlOption>
              </wsdlOptions>
            </configuration>
            <goals>
              <goal>wsdl2java</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring</artifactId>
      <version>2.5.6</version>
    </dependency>
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-bundle</artifactId>
      <version>2.2.10</version>
    </dependency>
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-transports-http</artifactId>
      <version>2.2.10</version>
    </dependency>
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-codegen-plugin</artifactId>
      <version>2.2.10</version>
    </dependency>				
  </dependencies>
</project>

 

Génération des sources à partir du fichier wsdl

Rien de plus simple, il suffit d’invoquer à la racine du projet la commande maven : mvn clean generate-sources Si tout se passe correctement, deux nouveaux packages avec leurs fichiers sources apparaissent : wsimplementation, et wsinterface. Vous pouvez désormais utiliser le webservice.

 

Le client

Dans la mesure où on chercher uniquement à illustrer notre propos, notre webservice sera invoqué par une simple classe java main. Cependant, le modèle est facilement adaptable à d’autres types de projet.

 

Le fichier applicationContext.xml

Le plus important dans ce fichier de configuration, hormis les dépendances, est la visibilité du webservice à proprement parler opérationnalisée par

<jaxws:client id="authentication" 
       serviceClass="wsinterface.AuthenticationService" 
       address="http://localhost:8080/WSAuthentication-0.0.1-SNAPSHOT/ws/authentication">
</jaxws:client>

dans lequel on indique le package et l’interface du webservice disponible dans le fichier wsdl.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:jaxws="http://cxf.apache.org/jaxws"
 xsi:schemaLocation="
 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

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

  <jaxws:client id="authentication" 
         serviceClass="wsinterface.AuthenticationService" 
         address="http://localhost:8080/WSAuthentication-0.0.1-SNAPSHOT/ws/authentication">
  </jaxws:client>
</beans>

 

Le source

Sous eclipse et dans le projet, créer le package wsauthentication. Dans ce package, créer une classe java main que l’on nomme CallWSAuthentication.
Pour notre exemple, nous devons charger le fichier Spring applicationContext.xml afin de récupérer une instance de notre webservice d’authentification AuthenticationService.
A partir de cette instance, nous pouvons invoquer les méthodes exposées par le webservice, dans notre cas la méthode exposée est getAccess qui prend en paramètres un identifiant et un mot de passe et renvoie un booléen indiquant si l’authentification est correcte ou non.

package wsauthentication;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import wsinterface.AuthenticationService;</code>

public class CallWSAuthentication {

  public static void main(String[] args) 
  {
    ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext(
      new String[] {"applicationContext.xml"});
    AuthenticationService authenticationServiceImpl = (AuthenticationService)classPathXmlApplicationContext.getBean("authentication");

    Boolean accessResult = authenticationServiceImpl.getAccess("tarzan","jane");
    System.out.println("tarzan, jane " + accessResult);
    accessResult = authenticationServiceImpl.getAccess("titi","gros minet");
    System.out.println("titi, gros minet " + accessResult);		
  }
}

[/s2If]
 

Conclusion

Vous avez désormais toutes les clés permettant de créer un webservice et de l’invoquer.

Trouvez vous efficace l’utilisation de CXF et Spring 3 ?