Arnaud CLERET

Implémenter simplement un service Java (JAX-WS)

Bon, je vois déjà les remarques de certains concernant ce billet mais rassurer vous je ne me suis pas converti à Java !

En fait, l'objectif est plutôt de communiquer une manière simple d'implémenter un Web Service basé sur JAX-WS à des fins de démos ou prototypes d'interopérabilité sans avoir à sortir une artillerie lourde du type serveur d'application, environnement de développement...

D'ailleurs, un grand merci à Stève Sfartz qui a pu nous transmettre cette approche lors des TechDays 2008.

Seul pré-requis à cette approche : l'installation du JDK que vous pouvez télécharger ici.
Une fois installé, il est juste nécessaire de créer les trois fichiers suivants :

1. Fichier d'implémentation du service : DemoService.java
2. Fichier de script de compilation du service : Compile.bat
3. Fichier de script de lancement et d'hébergement du service : Run.bat

Dans l'exemple suivant, le service exposera une méthode Notify prenant un paramètre d'entrée correspondant au message à afficher dans la console.

Dans le fichier DemoService.java, correspondant à l'impémentation de ce service, il suffit d'ajouter le code ci-après qui vous l'avouerez reste très proche d'une implémentation .Net C#. Deux méthodes sont à distinguer :

1. la méthode Notify qui correspond à l'opération exposée par le service et affiche sur la console le message transmis.
2. la méthode Main qui correspond au point d'entrée du programme et permet de publier le endpoint du service.

package Service;

import javax.jws.*;
import javax.jws.soap.SOAPBinding;
import javax.xml.ws.Endpoint;

@WebService(targetNamespace = "http://services.demo.fr/JAX-WS",
            name="AlertDispatcher",
            serviceName="DemoService")
@SOAPBinding(style=SOAPBinding.Style.DOCUMENT,
             use=SOAPBinding.Use.LITERAL)
public class DemoService
{
   @WebMethod(operationName="Notify", action="urn:Notify")
   public void Notify(@WebParam(name="message") String a)
   {
      System.out.println("Message : " + a);
   }

   @WebMethod(exclude=true)
   public static void main(String[] args)
   {
      String endpointUri = "http://localhost:8585/";
      Endpoint.publish(endpointUri, new DemoService ());
      System.out.println("Publishing JAX-WS at " + endpointUri);
   }
}

Une fois l'implémentation du service terminée, il est nécessaire de compiler la solution avant de l'exécuter.
Dans le fichier Compile.bat, correspondant au script de compilation, il suffit d'ajouter le code suivant :

set JAVA_HOME="C:\Program Files\Java\jdk1.6.0_04\"
set PATH=%ATH%;%JAVA_HOME%\bin

javac *.java

move *.class Service

wsgen -cp . Service.DemoService

pause

Seul paramètre à modifier si besoin est le nom de la classe d'implémentation du service. Dans ce cas précis : DemoService.

Une fois la compilation effectuée, il ne reste plus qu'a exécuter le service en le hostant en mode console.
Dans le fichier Run.bat, correspondant au script de lancement et d'hébergement du service, il suffit d'ajouter le code suivant :

set JAVA_HOME="C:\Program Files\Java\jdk1.6.0_04\"
set PATH=%ATH%;%JAVA_HOME%\bin

java Service.DemoService

pause

Comme précédemment, le seul paramètre à modifier si besoin le nom de la classe d'implémentation du service. Dans ce cas précis : DemoService.

Le service est donc maintenant hosté et prêt à être consommé :

Le contrat WSDL correspondant au service est disponible, dans notre cas, à l'adresse suivante : http://localhost:8585/DemoService?wsdl

La définition des données attendues par l'opération Notify est faite dans le schéma XSD se trouvant à l'adresse suivante : http://localhost:8585/DemoService?xsd=1

Il est donc désormais possible de consommer se service depuis une application Java mais aussi .Net avec deux approches différentes basées soit sur un client de type Web Service soit un client de type WCF en basicHttpBinding.
Pour ce faire, au travers de Visual Studio, il suffit de faire un Add Service Reference :

Une fois le service ajouté, la classe proxy et le fichier de configuration WCF générés, il est maintenant possible d'invoquer le service en quelques lignes de code :

AlertDispatcherClient client = new AlertDispatcherClient();
client.Notify("Interop JAX-WS / WCF is good !");
client.Close();

Au niveau de la configuration WCF et notamment du endpoint client, le constat est que la communication entre le service et le client sera de type basicHttpBinding sans autre élément particulier ou spécifique :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint
        name="AlertDispatcherPort"
        address="http://localhost:8585/DemoService" 
        binding="basicHttpBinding"
        contract="DemoService.AlertDispatcher" />
    </client>
  </system.serviceModel>
</configuration>

Il est donc maintenant possible d'exécuter le client et de constater qu'un message s'affiche bien sur la console du service JAX-WS :

Voilà, l'implémentation du serveur comme du client est terminée !

Le constat de cet exemple est qu'il est maintenant simplissime de monter un scénario d'interopérabilité entre .Net et Java sans pour autant faire appel à une artillerie lourde !

L'exemple de code exposé dans ce post est disponible aussi en téléchargement via le fichier zip attaché : télécharger.

Enjoy !