Cet article explique comment développer un service JBI (Java Business Integration) avec l'ESB Open Source ServiceMix (lire l'article ServiceMix pour comprendre la relation entre JBI, ESB et ServiceMix) et le langage dynamique Groovy, et de l'invoquer en utilisant un client AJAX.
La version de ServiceMix utilisée est la version 3.1, pour laquelle nous avons défini la variable d'environnement SERVICEMIX_INSTALL indiquant le répertoire d'installation de ServiceMix (par exemple C:\apache-servicemix-3.1-incubating, dans un environnement Windows).
Nous allons expérimenter l'appel d'un service JBI implémenté dans le langage dynamique Groovy et qui sera invoqué via le composant connecteur http de ServiceMix.
Autrement dit, notre service va pouvoir être invoqué au travers d'un client réalisant une requête http : le composant de connexion reçoit la requête provenant du client, la transmet au service Groovy qui, à tour renvoie une réponse au composant de connexion ; ce dernier la retransmet au client pour affichage.
Par simplification, notre client sera une simple page HTML comportant du code JavaScript pour effectuer une requête vers ServiceMix avec la librairie AJAX prototype.
Composants ServiceMix
Vous devez vérifier que les archives suivantes sont présentes dans le répertoire SERVICEMIX_INSTALL\install :servicemix-shared-3.1-incubating-installer.zipservicemix-script-3.1-incubating-installer.zipservicemix-http-3.1-incubating-installer.zip
Si ce n'est pas le cas, vous pouvez les copier depuis le répertoire SERVICEMIX_INSTALL\components.
Service Groovy
Le composant ServiceMix Script (correspondant à l'archive servicemix-script-3.1-incubating-installer.zip placée dans le répertoire SERVICEMIX_INSTALL\install) est un composant JBI permettant l'intégration avec les langages de script.
Comme beaucoup d'autres composants JBI de ServiceMix, ce composant agit comme un conteneur fournissant (ou consommant) des services basés sur des artefacts qu'il contient.
Il est ainsi possible d'écrire un service en langage Groovy, sous la forme d'un fichier, qui devra être déployé vers le composant ServiceMix Script. Ce fichier doit être placé dans un « Service Unit » (SU), qui est un package zippé contenant les artefacts du service.
En plus du fichier contenant le code Groovy, il faut ajouter dans le package, un fichier de configuration XML XBean compréhensible par le composant ServiceMix Script (voir la page ServiceMix Script).
Afin de déployer notre service Groovy, notre fichier SU doit être packagé dans un fichier de type « Service Assembly » (SA) qui, selon la spécification JBI, est un fichier zip servant à contenir le ou les fichiers SU, mais aussi le fichier de description jbi.xml. Le fichier jbi.xml permet d'indiquer en particulier le composant cible vers lequel déployer les fichiers SU, dans notre cas le composant servicemix-script.
Revenons au code Groovy du fichier GroovyExchangeProcessor.groovy :
import javax.jbi.messaging.NormalizedMessage
import javax.jbi.messaging.ExchangeStatus
import org.apache.servicemix.common.ExchangeProcessor
import org.apache.servicemix.jbi.jaxp.StringSource
import org.apache.servicemix.script.ScriptExchangeHelper
import org.apache.servicemix.jbi.jaxp.SourceTransformer
import groovy.xml.MarkupBuilder
class GroovyExchangeProcessor implements ExchangeProcessor {
ScriptExchangeHelper exchangeHelper;
def void start() {
println "Démarrage du service Groovy..."
}
def void process(MessageExchange exchange) {
if (exchange.status == ExchangeStatus.DONE) return
def inputMessage = new SourceTransformer().toString(exchange.getInMessage().getContent())
def xml = new XmlSlurper().parseText(inputMessage)
def writer = new StringWriter()
def builder = new MarkupBuilder(writer)
builder.div {
h3('Réponse du service Groovy')
p() {
b('Message reçu :')
span(inputMessage)
}
p() {
b('Donnée extraite :')
span(xml.nom)
}
table(border: '1') {
thead() {
tr() {
th('Propriété')
th('Valeur')
}
}
tbody() {
exchange.propertyNames.each { prop ->
tr() {
td(prop)
td(exchange.getProperty(prop))
}
}
}
}
}
NormalizedMessage out = exchange.createMessage()
out.setContent(new StringSource(writer.toString()))
exchange.setOutMessage(out)
exchangeHelper.sendExchange(exchange)
}
def void stop() {
println "Arrêt du service Groovy"
}
}
Le message XML transmis au service est récupéré dans la variable inputMessage, puis lu dans un object Groovy XmlSlurper, ce qui va grandement faciliter l'accès aux éléments du document XML.
Ensuite, nous avons recours au builder MarkupBuilder pour construire un message XML comme réponse : ici, nous construisons un fragment de code HTML qui est ensuite défini comme message de réponse.
A titre d'exemple, nous écrivons en particulier dans le message XML de réponse, un tableau contenant les valeurs des propriétés rattachés à l'échange de messages (objet MessageExchange).
Nous voyons bien que l'agilité du langage Groovy nous est d'un grand secours ! Mais cela ne s'arrête pas là : dans un prochain article nous expliquerons comment Groovy peut servir à générer le fichier Service Assembly JBI.
Vous pouvez récupérer en tant que pièce jointe à cet article, le fichier SA ServiceGroovy-SA.zip définissant notre service Groovy.
Pour déployer ce service dans ServiceMix à l'exécution, il suffit de copier ce fichier dans le répertoire SERVICEMIX_INSTALL\deploy.
Composant de connexion http
Afin de permettre l'invocation de notre service Groovy nous utiliserons le composant ServiceMix servicemix-http. Le composant ServiceMix servicemix-http est un composant JBI de connexion offrant un support de connexion HTTP/SOAP.
Nous déployons un Service Assembly (SA) vers le composant servicemix-http : ce fichier défini un nouveau service qui permettra le démarrage d'un serveur http, à l'écoute de requêtes clientes ; les messages reçus par ce service seront acheminés vers le service Groovy.
Le fichier SA contient uniquement un fichier SU contenant le fichier de configuration xbean.xml suivant :
<http:endpoint service="test:MonServiceConsommateur"
endpoint="monConsommateurr"
role="consumer"
locationURI="http://localhost:8192/Service/"
defaultMep="http://www.w3.org/2004/08/wsdl/in-out"
targetService="test:groovy"/>
</beans>
Ce fichier de configuration définit en particulier le type d'échange de messages, ici aller-retour (in-out), ainsi que l'URI (http://localhost:8192/Service/) devant être utilisée pour l'envoi de messages http par un client.
L'attribut targetService définit le service à invoquer, ici notre service Groovy appelé test:groovy ; ce nom de service est repris dans le fichier de configuration xbean.xml présent dans le SU du service Groovy.
Remarquez bien l'intérêt de séparer les services métiers des services de connexion. Notre service métier Groovy ne se préoccupe jamais du mode de transport des messages et se concentre uniquement sur l'aspect fonctionnel.
Il existe bien d'autres composants de connexions, et en changer revient à effectuer du paramétrage. Par exemple, le service Groovy pourrait être invoqué à la suite de l'apparition d'un fichier dans un répertoire surveillé par un service de connexion de type fichier.
Vous pouvez récupérer en tant que pièce jointe à cet article, le fichier SA Connecteur-SA.zip définissant le service HTTP.
Pour déployer ce service dans ServiceMix à l'exécution, il suffit de copier ce fichier dans le répertoire SERVICEMIX_INSTALL\deploy.
Client AJAX
Après avoir expliqué comment déployer dans ServiceMix notre service Groovy, qui est rendu accessible par une connexion http, il nous reste à donner un exemple d'invocation de ce service.
Pour cela, nous aurons recours à une simple page HTML et à la librairie AJAX prototype (version 1.5.1). Le source de la page est reproduit ci-dessous (ce source est disponible en tant que pièce jointe, mais vous aurez aussi besoin de télécharger le fichier prototype.js depuis le site de prototype) :
<head>
<title>Test de ServiceMix</title>
<script type="text/javascript" src="prototype.js"></script>
<script type="text/javascript">
function traiter() {
new Ajax.Updater('reponse', 'http://localhost:8192/Service/',
{
method: 'post',
postBody: '<contact><nom>odelia</nom></contact>',
onSuccess: function(transport) {
var response = transport.responseText || "pas de réponse texte";
},
onFailure: function() { alert("Quelque chose s'est mal passé !") }
});
}
</script>
</head>
<body>
Client ServiceMix
<button onclick="traiter()">Test</button>
<div id="reponse"></div>
</body>
</html>
Ce code est relativement simple : au click sur le bouton de la page (voir la capture d'écran plus bas), la fonction JavaScript traiter est appelée ; un objet de la librairie prototype est instancié avec les paramètres qui permettent d'effectuer une requête http de type POST vers l'URI passée en second argument. Cette adresse est bien sûr celle du service de connexion http.
Le document XML servant de message JBI est défini par le paramètre postBody : ce message est donc transmis avec la requête http. Si tout ce passe bien, l'objet Ajax.Updater injecte le message de réponse, qui est un fragment de code HTML généré par le service Groovy, dans l'élement div ayant l'id « reponse » (cet id est indiqué comme premier argument dans la construction de l'objet Ajax.Updater).
Pour tester le tout, voici la marche à suivre :
- démarrer ServiceMix (sous Windows, en vous servant de SERVICEMIX_INSTALL\bin\servicemix.bat) ;
- déployer les fichiers SA ServiceGroovy-SA.zip et Connecteur-SA.zip par simple copie dans le répertoire SERVICEMIX_INSTALL\deploy
- ouvrez la page html test-prototype.html avec Internet Explorer 7 et actionnez le bouton « Test » (vous aurez un avertissement de sécurité que vous pourrez passer outre ; attention pour des raisons de sécurité le test risque de ne pas fonctionner si vous utilisez le navigateur FireFox)
Vous devriez voir apparaître quelque chose comme ceci :
| Fichier attaché | Taille |
|---|---|
| ServiceGroovy-SA.zip | 6.11 Ko |
| Connecteur-SA.zip | 863 octets |
| test-prototype.html.txt | 697 octets |