Architecture RESTFul 0

Posted décembre 29, 2008

REST: REpresentationnal State Transfer

Style d’architecture RESTful

REST se définit comme un style d’architecture pour des systèmes distribués.

Au centre de ces concepts, il y a la notion de ressources identifiées par un URI ( Universal Resource Identifier).
La ressource peut être mainipulée en utilisant une interface http standard, et des informations sont échangées en utilisant des representations de cette ressource.

Les RESTful Web Services sont construits en utilisant ce style d’architecture. Cette approche devient une alternative de plus en plus répandue à l’approche SOAP.

Un bon exemple vaut mieux qu’un long discour

Par exemple à la requête http GET:

http://localhost:8080/bgREST/resources/formationReservations/1

On aura la réponse (Si l’on accepte les documents xml,mais si l’on accepte les documents json, on aura la même ressource au format json):

<?xml version="1.0" encoding="UTF-8"?> version="1.0" encoding="UTF-8" standalone="yes"
<formationReservation uri="http://localhost:8080/bgREST/resources/formationReservations/1/">
<company>SQLI</company>
<dateFormation>2008-12-14T00:00:00+01:00</dateFormation>
<id>1</id>
<name>Pierre</name>
<nbEleves>2</nbEleves>
</formationReservation>

wadl : Web Application Description Language

Le wadl permet de décrire un Web Service de style RESTful dans un fichier xml.

Ils sont similaires aux fichiers wsdl qui sont destinés à décrire les Web Services de type SOAP.

Les fichiers wadl sont en général générés automatiquement par les outils qui construisent les Web Services.

D’autres outils (wadl2java) permettent de générer du code dans un langage de programmation pour inter-réagir avec un Web Service.

Cette approche , qui tente de reproduire ce qui se fait dans le monde WS-* est critiquée : http://bitworking.org/news/193/Do-we-need-WADL

Dans notre exemple, pour la requete:

http://localhost:8080/bgREST/resources/application.wadl

Voilà le wadl:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<application xmlns="http://research.sun.com/wadl/2006/10">
<doc xmlns:jersey="http://jersey.dev.java.net/" jersey:generatedBy="Jersey: 1.0 10/13/2008 12:27 PM"/>
<resources base="http://localhost:8080/bgREST/resources/">
<resource path="/formationReservations/">
<method name="GET" id="get">
<request>
<param xmlns:xs="http://www.w3.org/2001/XMLSchema" default="0" type="xs:int" style="query" name="start"/>
<param xmlns:xs="http://www.w3.org/2001/XMLSchema" default="10" type="xs:int" style="query" name="max"/>
<param xmlns:xs="http://www.w3.org/2001/XMLSchema" default="1" type="xs:int" style="query" name="expandLevel"/>
<param xmlns:xs="http://www.w3.org/2001/XMLSchema" default="SELECT e FROM FormationReservation e" type="xs:string" style="query" name="query"/>
</request>
<response>
<representation mediaType="application/xml"/>
<representation mediaType="application/json"/>
</response>
</method>
<method name="POST" id="post">
<request>
<representation mediaType="application/xml"/>
<representation mediaType="application/json"/>
</request>
<response>
<representation mediaType="*/*"/>
</response>
</method>
<resource path="{id}/">
<param xmlns:xs="http://www.w3.org/2001/XMLSchema" type="xs:long" style="template" name="id"/>
<method name="GET" id="get">
<request>
<param xmlns:xs="http://www.w3.org/2001/XMLSchema" default="1" type="xs:int" style="query" name="expandLevel"/>
</request>
<response>
<representation mediaType="application/xml"/>
<representation mediaType="application/json"/>
</response>
</method>
<method name="PUT" id="put">
<request>
<representation mediaType="application/xml"/>
<representation mediaType="application/json"/>
</request>
</method>
<method name="DELETE" id="delete"/>
</resource>
</resource>
</resources>
</application>

Liste des ressources

Pour la requête :

http://localhost:8080/bgREST/resources/formationReservations

On optient la liste des ressources :

<?xml version="1.0" encoding="UTF-8"?> version="1.0" encoding="UTF-8" standalone="yes"
<formationReservations uri="http://localhost:8080/bgREST/resources/formationReservations/">
<formationReservation uri="http://localhost:8080/bgREST/resources/formationReservations/1/">
<company>SQLI</company>
<dateFormation>2008-12-14T00:00:00+01:00</dateFormation>
<id>1</id>
<name>Pierre</name>
<nbEleves>2</nbEleves>
</formationReservation>
<formationReservation uri="http://localhost:8080/bgREST/resources/formationReservations/2/">
<company>ebay</company>
<dateFormation>2008-12-14T00:00:00+01:00</dateFormation>
<id>2</id>
<name>Jacques</name>
<nbEleves>4</nbEleves>
</formationReservation>
<formationReservation uri="http://localhost:8080/bgREST/resources/formationReservations/3/">
<company>airbus</company>
<dateFormation>2008-12-14T00:00:00+01:00</dateFormation>
<id>3</id>
<name>Paul</name>
<nbEleves>1</nbEleves>
</formationReservation>
</formationReservations>

REST et java

La JSR 311 , JAX-RS a comme implementation jersey (Proposé par SUN)

REST et netbeans

Netbeans supporte un certain nombre de fonctionnalités permettant de très rapidement concevoir, déployer et tester des Web Services RESTful.

Voir: Simple Exemple à partir de netbeans

Business Process Execution Language (BPEL): Ecrire un premier Web-Service avec netbeans 0

Posted juin 29, 2008

BPEL permet de manipuler des web-services (on dit composer ou orchestrer) et génère lui-même un web service, défini par un wsdl , qui lui même s’appuie sur des schéma (xsd).

Netbeans, le célèbre IDE gratuit de SUN permet de réaliser assez facilement une application, et de la déployer sur un serveur jbi Glassfish.

Nous allons essayer de construire une application de type "HelloWorld"

Cela passe par les étapes suivantes:

Créer un schéma xsd
Créer un wsdl
Créer un bpel
Déployer et tester

Il est impossible d’écrire des fichiers aussi complexes à la main. Il faut un outil: netbeans.

Ecrire un xsd (un schema)

Créer un nouveau projet : new Project>SOA>BPEL Module
Créer un nouveau schema: ProcessFils>New>XML schema donner un nom au fichier
Rajouter un type complexe (ie : contactDetails)
Dans la séquence de « contact» , rajouter des champs comme firstName, lastName, address, email … de type (existing type) String
Rajouter une deuxièmme type complexe (ie : contactTitre), de type String celui ci (pour changer!)
Rajouter 2 « elements» , des types complexes que nous avons définis précédemment

Remarque: Vous pouvez définir des éléments de type « simple» (String par exemple) . Mais cela semble créer des problèmes …

Voilà le xsd sous sa forme xml:

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://xml.netbeans.org/schema/mySchema"
xmlns:tns="http://xml.netbeans.org/schema/mySchema"
elementFormDefault="qualified">
<xsd:complexType name="ContactDetails">
<xsd:sequence>
<xsd:element name="firstName" type="xsd:string"></xsd:element>
<xsd:element name="lastname" type="xsd:string"></xsd:element>
<xsd:element name="email" type="xsd:string"></xsd:element>
<xsd:element name="address" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="aContactDetails" type="tns:ContactDetails"></xsd:element>
<xsd:complexType name="ContactSimple">
<xsd:simpleContent>
<xsd:extension base="xsd:string"/>
</xsd:simpleContent>
</xsd:complexType>
<xsd:element name="aContactSimple" type="tns:ContactSimple"></xsd:element>
</xsd:schema>

Ecrire un wsdl

ProcessFiles>new>wsdl document
Premier écran: Importer le schéma que nous venons de définir
next
définir les entrées et les sorties

Voila le wsdl sous sa forme xml:

<?xml version="1.0" encoding="UTF-8"?>
<definitions name="myWsdl" targetNamespace="http://j2ee.netbeans.org/wsdl/myWsdl"
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://j2ee.netbeans.org/wsdl/myWsdl" xmlns:ns="http://xml.netbeans.org/schema/mySchema" xmlns:plnk="http://docs.oasis-open.org/wsbpel/2.0/plnktype" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<types>
<xsd:schema targetNamespace="http://j2ee.netbeans.org/wsdl/myWsdl">
<xsd:import namespace="http://xml.netbeans.org/schema/mySchema" schemaLocation="mySchema.xsd"/>
</xsd:schema>
</types>
<message name="myWsdlOperationRequest">
<part name="part1" element="ns:aContactDetails"/>
</message>
<message name="myWsdlOperationResponse">
<part name="part1" element="ns:aContactSimple"/>
</message>
<portType name="myWsdlPortType">
<operation name="myWsdlOperation">
<input name="input1" message="tns:myWsdlOperationRequest"/>
<output name="output1" message="tns:myWsdlOperationResponse"/>
</operation>
</portType>
<binding name="myWsdlBinding" type="tns:myWsdlPortType">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="myWsdlOperation">
<soap:operation/>
<input name="input1">
<soap:body use="literal"/>
</input>
<output name="output1">
<soap:body use="literal"/>
</output>
</operation>
</binding>
<service name="myWsdlService">
<port name="myWsdlPort" binding="tns:myWsdlBinding">
<soap:address location="http://localhost:${HttpDefaultPort}/myWsdlService/myWsdlPort"/>
</port>
</service>
<plnk:partnerLinkType name="myWsdl">
<!-- A partner link type is automatically generated when a new port type is added. Partner link types are used by BPEL processes.
In a BPEL process, a partner link represents the interaction between the BPEL process and a partner service. Each partner link is associated with a partner link type.
A partner link type characterizes the conversational relationship between two services. The partner link type can have one or two roles.-->
<plnk:role name="myWsdlPortTypeRole" portType="tns:myWsdlPortType"/>
</plnk:partnerLinkType>
</definitions>

Créer un bpel

ProcessFiles>new>bpel
Dans la vue design, « Drag and drop» le fichier wsdl. Les positions où il peut se positionner sont sur les côtés
« Drag And Drop» l’élément « receive» de la palette vers le centre design . Parfois la palette est invisible! click droit au centre du design Add From Pallette> Web Service > Receive
Editer l’élément receive, lui donner un nom (myReceive), L’associer à un « Partner link» ,à une opération, créer une variable « input»
Mettre en place de la même manière l’élément « reply» sous l’élément « receive» . Définir une variable « output»
Mettre en place un élément assign. (entre les éléments receive et reply)
Sélectionner l’élément « assign» Choisir la vue « mapper»
Sélectionner la variable output (celle dans laquelle on veut assigner une valeur)

voilà le xml correpondant:

<?xml version="1.0" encoding="UTF-8"?>
<process
name="myBpel"
targetNamespace="http://enterprise.netbeans.org/bpel/bg_test_005/myBpel"
xmlns="http://docs.oasis-open.org/wsbpel/2.0/process/executable"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://enterprise.netbeans.org/bpel/bg_test_005/myBpel" xmlns:ns0="http://j2ee.netbeans.org/wsdl/myWsdl" xmlns:sxt="http://www.sun.com/wsbpel/2.0/process/executable/SUNExtension/Trace" xmlns:sxed="http://www.sun.com/wsbpel/2.0/process/executable/SUNExtension/Editor" xmlns:ns1="http://xml.netbeans.org/schema/mySchema">
<import namespace="http://j2ee.netbeans.org/wsdl/myWsdl" location="myWsdl.wsdl" importType="http://schemas.xmlsoap.org/wsdl/"/>
<partnerLinks>
<partnerLink name="PartnerLink1" xmlns:tns="http://j2ee.netbeans.org/wsdl/myWsdl" partnerLinkType="tns:myWsdl" myRole="myWsdlPortTypeRole"/>
</partnerLinks>
<variables>
<variable name="MyWsdlOperationOut" xmlns:tns="http://j2ee.netbeans.org/wsdl/myWsdl" messageType="tns:myWsdlOperationResponse"/>
<variable name="MyWsdlOperationIn" xmlns:tns="http://j2ee.netbeans.org/wsdl/myWsdl" messageType="tns:myWsdlOperationRequest"/>
</variables>
<sequence name="Sequence2">
<sequence name="Sequence1">
<sequence>
<receive name="Receive1" createInstance="yes" partnerLink="PartnerLink1" operation="myWsdlOperation" portType="ns0:myWsdlPortType" variable="MyWsdlOperationIn"/>
<assign name="Assign1">
<copy>
<from>concat($MyWsdlOperationIn.part1/ns1:firstName, $MyWsdlOperationIn.part1/ns1:lastname, $MyWsdlOperationIn.part1/ns1:email, $MyWsdlOperationIn.part1/ns1:address)</from>
<to variable="MyWsdlOperationOut"/>
</copy>
</assign>
<reply name="myReply" partnerLink="PartnerLink1" operation="myWsdlOperation" portType="ns0:myWsdlPortType" variable="MyWsdlOperationOut"/>
</sequence>
</sequence>
</sequence>
</process>

Déployer et tester le projet sur le serveur

Remarquez qu’un projet BPEL n’est pas directement déployable.

Il doit être rajouté en tant que module JBI dans un projet « Application Composite» qui sera ensuite déployée.

Créer le projet « Application Composite» et rajouter les modules JBI:

Depuis le menu principal : File > New Project
Sémectionner le mode « Composite Application»
Next
Rajouter un nom, « finish»
Ouvrir ce nouveau projet « Composite Application» . « Click Droit» . choisir « Add JBI Module» Sélectionner le jar du projet BPEL que vous voulez rajouter
Remarquez qu’un jar a été rajouté dans le module JBI
Sur le projet « Application Composite» , click droit, choisir « Deploy Project»
Dans le projet « Composite Application» /Test, click droit et choisir « new test»
Sur le test créé, click droit « run»

ressources

the other netbeans bpel tutorial

netbeans helloword application

Sercices Oriented Architecture: Les outils et ressources de base 0

Posted mai 17, 2008

Les outils:

Deux éditeurs sont incontournables: Netbeans et Eclipse.
Netbeans propose des editeurs bpel , xsd et wsdl assez intuitifs. Il est particulièrement adapté à glassfish pour tester des applications jbi.

De la même manière, Eclipse propose de nombreux plugins permettant de développer des applications bpel et bpmn. La démarche serait plutot top down: Je commence par écrire un fichier bpmn ( Des spécifications uniquement business) et j’arrive à générer un fichier bpel (Un langage d’execution). Eclipse est plustot destiné à générer des applications jbi pour servicemix.
Il existe une version d’eclipse comportant tous les plugins: spagic.

Pour ceux qui veulent apprendre à manipuler BPEL, je conseille netbeans.

JBI : Un exemple avec ServiceMix 0

Posted mai 15, 2008

Ce tutorial accompagne la création d’une première application:
Il s’agit de surveiller un répertoire, et lorsqu’un fichier xml apparaît dans ce répertoire, le déplacer vers un autre répertoire, et envoyer le contenu dans une queue JMS et d’en archiver une copie.

JBI Components

Les JBI Components (Binding Components et « Service Engine» ) sont des plug-ins qui rajoutent des fonctionnalités au « JBI Container» .

Vous pouvez installer un « JBI Component» en le copiant dans le répertoire « hotdeploy» .

Un « JBI Component» se compose d’un fichier zip, appelé aussi « Service Assembly» ou SA.
Un SA se compose:

D’un fichier META-INF/jbi.xml
De plusieurs fichier zip appelés SU (Service Unit) . Chaque SU contient au moins un fichier xbean.xml

Il est possible de regarder les Components déployés avec une console jmx (jconsole), d’arrêter ou de démarrer les SA.

Créer un SA (Service Assembly)

Créer un projet

Recopier ce pom.xml dans un directory vide.

4.0.0 bg.servicemix parent 1.0-SNAPSHOT pom Tutorial http://servicemix.org

Exécuter la commande:

mvn install

Cela valide le fait que mvn est installé, et que le fichier pom.xml est correct.

ServiceMix fournit plusieurs achetypes Maven pour faciliter la créattion de projets.

Créer un projet SU (Service Unit) avec Maven et l’archetype « servicemix-service-unit»

Nous commencerons par utiliser l’archétype permettant de créer des SU (Service Unit)

Depuis le directory que nous avons créé, la commande suivante créera un « service unit» projet appelé « tutorial-file-su» :

mvn archetype:create -DarchetypeArtifactId=servicemix-service-unit -DarchetypeGroupId=org.apache.servicemix.tooling -DarchetypeVersion=3.2.1 -DartifactId=tutorial-file-su

Mettre la version correspondant à la version de serviceMix.

Nous remarqons que le premier fichier pom.xml que nous avions écrit a été modifié, et qu’un nouveau répertoire a été créé, contenant un pom.xml.

Rajouter une dépendance pour un « component» JBI

Chaque SU (Service Unit) est detiné à être un « component» JBI. Nous spécifions cela dans le pom.xml , en rajoutant une dépendance au pom.xml.

L’outillage maven de servicemix fera le reste.

Le component « servicemix-file» fournit l’integration du JBI aux fichiers. Il peut être utilisé pour lire et écrire des fichiers, ou surveiller (poll) un répertoire.Il est décrit ici

org.apache.servicemix servicemix-file ${servicemix-version}

Configurer le xbean.xml

Ensuite, nous aurons à configurer notre nouveau SU pour fournir réellement un service.
Nous faisons cela en créant un fichier appelé xbean.xml dans le répertoire src/main/resources

L’exemple définit 2 namespaces: Le prefixe « file» fait référence à un namespace pour adresser les fonctionnalités standard, tandis que le prefixe « tut» sera utilisé pour le namespace dans lequel notre service sera défini.

Définition d’un « file sender endpoint»

Un « file sender» peut être utiliser pour écrire des fichiers localement.
Voilà un exemple de « file sender» :

Remarquez les 2 attributs service (Qui font référence à l’ensemble du SU) et endpoint (Qui fait référence au sein du service , à cet interface file:sender).

Définition d’un « file poller endpoint»

Nous allons lire les fichiers XML dans un répertoire (spécifié par l’attribut « file» , aussi veillez a ce que ce directory existe sur votre système )

La ligne XML ci-dessous est destinée à configurer un « poller» , qui vérifiera la presence d’un nouveau fichier toutes les n secondes. Ce fichier sera envoyé au « file sender» endpoint spécifié par les attributs « targetService» et « targetEndpoint» .

Le poller appartient au même service que le « sender» ; mais à un autre endpoint.Il a 2 attributs targetService et targetEndpoint qui désignent vers quelle appli seront envoyée les fichiers (Dans notre exemple,c’est le même service).

En résumé:

Vous spécifiez le component cible pour un SU comme une dépendance dans Maven (» dependancy» dans le pom.xml).

Dans ServiceMix, la pluspart des SU seront configurés par des fichiers xbean.xml

Créer le SA (» Service Assembly» ) avec Maven et l’archetype « servicemix-service-assembly»

De la même manière que nous avons créer notre SU avec un archetype Maven, nous allons créer notre projet SA .

Exécuter cette commande :

mvn archetype:create -DarchetypeArtifactId=servicemix-service-assembly -DarchetypeGroupId=org.apache.servicemix.tooling -DarchetypeVersion=3.2.1 -DartifactId=tutorial-sa

Un nouveau projet a été généré

Ajouté le SU dans le SA

Nous voulons ajouter le SU que nous avons créé au SA. L’outil Maven le fera automatiquement si nous mettons une dépendance dans le pom.xml du SA.
Nous avons à utiliser le groupId, l’artifactId et la version du SU ici:

xxx org.apache.servicemix.tutorial tutorial-file-su 1.0-SNAPSHOT xxxx

Utilisons Maven pour construire l’ensemble:

mvn install

Déployer le SA

Avant de commencer, assurez vous que ServiceMix est démarré.

Maintenant , naviguez dans le directory de votre SA, et utiliser le plugin JBI « Maven» pour déployer votre projet:

cd tutorial-sa mvn jbi:projectDeploy

Tester le SA

Nous avons configurer notre SU « file» pour surveiller la presence de fichiers dans un directory, et les envoyer à un autre répertoire.
Copier juste un fichier xml dans le répertoire surveillé, et ServiceMix le déplacera après quelques secondes vers le « endpoint»

Rajouter 2 SU

A la place de simplement copier des fichiers depuis un directory vers un autre, nous allons maintenant envoyer un message vers une queue JMS. Nous voulons aussi archiver une copie du message en utilisant le pattern « wiretap» .

En premier, nous avons à créer 2 projets supplémentaires pour nos 2 SU.
A la place d’utiliser le simple archetype « servicemix-service-unit» comme precedemment,nous allons utilser 2 nouveaux archetypes:

« servicemix-eip-service-unit» pour créer le module « tutorial-eip-su»
« servicemix-jms-provider-service-unit» pour créer le module « tutorial-jms-su»

Nous connaissons la syntaxe:
mvn archetype:create -DarchetypeArtifactId=XX -DarchetypeGroupId=org.apache.servicemix.tooling -DartifactId=YY

mvn archetype:create -DarchetypeArtifactId=servicemix-eip-service-unit -DarchetypeGroupId=org.apache.servicemix.tooling -DarchetypeVersion=3.2.1 -DartifactId=tutorial-eip-su mvn archetype:create -DarchetypeArtifactId=servicemix-jms-provider-service-unit -DarchetypeGroupId=org.apache.servicemix.tooling -DarchetypeVersion=3.2.1 -DartifactId=tutorial-jms-su

Ces archetypes sont un peu plus sophistiqué :
Ils ajoutent les < dependency > pour les components JBI qu’ils ciblent. Ils fournissent un xbean.xml pour démarrer.

Après cela, ajouter ces 2 nouveaux SU au SA en rajoutant les < dependency > au pom.xml du SA.

La documentation de serviceMix décrit comment utiliser jms : servicemix-jms.

Modifier le fichier xbean.xml de tutorial-jms-su, afin d’accéder à une queue appelée « queue/tutorial» sur ActiveMQ (qui est embarqué dans ServiceMix).

Configurer le « tutorial-eip-su»

Le « Servicemix-eip component» est un container « routeur» où plusieurs types de routage peuvent être déployés en tant que SU.

Modifier le fichier xbean.xml de « tutorial-eip-su» pour définir le « wiretap» que nous voulons.

Les différents pattern sont définis dans la doc de ServiceMix-eip
voici le shema du « wire-tap» pattern:

Nous voulons envoyer les messages au « jms endpoint» , aussi, nous spécifions cette information au premier < eip:exchange-target/ >

Le deuxième fait référence au endpoint < file:sender /> que nous avons déclaré plus tôt.

Modifier la configuration de tutorial-file-su

Nous avons à modifier le « targetService» du endpoint < file:poller > pour réferrer à notre nouvellement créé « wiretap» .
Cela pourrait être comme cela:

Construire et deployer

Quand tout est fait, vous étes prèt pour construire et deployer le SA.
Lors du build, les logs devraient ressembler à cela:

[INFO] Scanning for projects… [INFO] Reactor build order: [INFO] Tutorial [INFO] Tutorial :: File SU [INFO] Tutorial :: JMS SU [INFO] Tutorial :: EIP SU [INFO] Tutorial :: SA … [INFO] ——————————– [INFO] BUILD SUCCESSFUL [INFO] ——————————– …

Test

Si vous copiez un fichier dans le directory surveillé par le « poller» , il sera copié dans le directory « sender» , comme avant.

Cependant, il devrait aussi y avoir une copie du message dans notre queue JMS.

Pour le controller, connectez vous à ServiceMix avec la console JMX et naviguez vers org.apache.activemq/localhost/Queues.

Une queue devrait avoir été créée avec le nom « queue/tutorial» et l’attribut « EnqueueCount» indique le nombre de messages qui ont déjà été envoyés.

JBI – Java Business Integration: C’est quoi ? 0

Posted mai 15, 2008

JBI est un standard java (JSR 208) qui définit une architecture pour permettre l’interoperabilité d’applications avec un système d’échanges de messages.
Les messages entre les « components» sont échangés à travers un « Normalized Message Router» (NMR). Le NMR sert de « Message Exchange Pattern» (MEP). Le NMR sert d’intermédiare pour échanger des messages, quelquesoit l’endroit où est le « Component» . Les plugins ne communiquent pas directement les uns avec les autres: Ils communiquent exclusivement vers le NMR.

jbi

JBI Components

Les « plugins» mentionné ci-dessus sont quelquefois appelé « JBI components» .

« Binding Components»

Un « binding component» (BC) a 2 buts:

Communiquer en utilisant un protocole distant.
Normaliser les messages reçus

Les BC sont utilisés pour communiquer en dehors l’environnement JBI.

Exemples de protocoles fournis par les BC: http, jms,ftp,smtp,xmpp,rmi,corba,xmpp

JBI Components

Les JBI Components (Binding Components et « Service Engine» ) sont des plug-ins qui rajoutent des fonctionnalités au « JBI Container» .

Vocabulaire

Java Business Integration (JBI) : C’est le nom d’une JSR (Java Spécification)
Entreprise Service Bus (ESB) : C’est la même chose qu’un JBI, mais pas forcemment normalisé.
Component Les composants proposent des services accessibles par l’intermédiaire d’interfaces. Ce sont les parties enfichables dans le framework JBI. Il se divisent en deux sous-familles:Service Engine (SE) et Binding Component (BC)
Service Engine (SE) :Les SE fournissent la logique métier et les transformations (XSLT, …). Il peuvent consommer eux-même d’autres SE.
Binding Component (BC) : Les BC fournissent la connectivité, qu’il s’agisse de protocoles (FTP, HTTP,…), de piles (SOAP, JMS, …) ou de services externes au conteneur JBI. Ils permettent l’accès de depuis l’extérieur au services d’une application JBI.
Rôles : Les composants peuvent avoir les rôles suivants : Consumer (Le composant utilise un service ) et Provider (Le composant fournit un service ) Chaque composant peut être à la fois consumer et provider.
EndPoint :Les services proposés par les composants sont accessibles via des endpoints. Un service correspond à un endpoint.
Normalized Message Router (NMR) :Le Normalized Message Router reçoit et envoi des messages de la part de composants. Il est responsable du routage des messages. Les messages sont tous dans un format normalisé
Normalized Message :Les Normalized Messages sont les messages echangés par une application JBI. Ce sont des documents XML formé u contexte du message ( Il inclut des informations tels que le protocole de communication, des informations spécifiques à d’autres composants … )et du contenu du message (Toutes les données)
Delivery Channel :Les composants se « connectent » sur le NMR grâce au delivery channel. C’est une voie de communication bidirectionnelle leur permettant d’envoyer et de recevoir les messages
Service Unit (SU) :Chaque composants à déployer est défini dans un SU. Celui contient toutes les informations relatives au composants (fiche de transformation Xslt… ) et obligatoirement un descripteur qui se trouve dans un dossier META-INF à la raçine de l’archive.
Service Assembly (SA) :Les composants qui doivent interagir ensemble sont rassemblé dans un SA. Celui-ci contient obligatoirement un descripteur où se trouvent toutes les informations relatives aux SUs à deployer, ainsi que les archives de ces Sus.

Dans notre prochain tutorial, nous implementeront une application sur ServiceMix

wsdl – Web Services Description Language 0

Posted mai 10, 2008

WSDL (Web Services Description Language) est un langage xml pour décrire les Web-Services et comment y accéder.

Structure d’un wsdl

Un wsdl décrit un Web-Service avec ces principales bailises:

La structure principale d’un wsdl ressemble à cela (liste non exhaustive):

<definitions>
<types>
definition des types........
</types>
<message>
definition des messages ....
</message>
<portType>
definition des ports (opérations et messages).......
</portType>
<binding>
Les protocoles de communication utilisés par le web-service
</binding>
<service>
Une adresse physique où accéder au service.
</service>
</definitions>

WSDL « portType»

L’élément < portType > est l’élément le plus important

Il décrit un web-service , les opérations qui peuvent être accomplies, et les messages échangés.

L’élément < portType > peut être comparé à une fonction d’une librairie dans un langage traditionnel.

Messages WSDL

L’élément < message > définit les données d’une opération.

Chaque message peut être formé d’une ou plusieurs partie. Les parties peuvent être comparés aux paramètres d’une fonction dans un langage de programmation traditionnel.

Operation Types

Les type de « Request-response» est l’opération la plus courrante. Mais wsdl définit d’autres types d’opération (» One-way» , « Solicit-response» ,» Notification» )

Outil / editeur

Il est quasiment impossible d’écrire un wsdl à la main.(Sans erreurs!)

J’utilise l’éditeur wsdl d’eclipse (voir le projet STP, ils proposent un plugin avec l’ensemble de leurs outils), qui est gratuit et qui marche bien.

Cet outil permet à la fois d’éditer un fichier wsdl, mais aussi, de comprendre sa structure et de quoi il est composé: C’est une bonne idée d’éditer un wsdl existant, et de le regarder avec cet outil.

BPMN – Business Process Modeling Notation 1

Posted mai 7, 2008

BPMN – Business Process Modeling Notation – définit essentiellement les tâches métier et leurs relations en format xml (wikipedia).

Le plugin « Eclipse STP Modeler» permet de créer des fichiers BPMN.
Nous allons essayé de créer un projet avec ce plugin.

Voilà un exemple de représentation BPML d’un processus métier:

Figure 1. Model of a business process

Ce schéma montre un unique flux horizontal d’un processus métier coupé en trois tranches et disposé verticalement dans l’ordre.
Ce schéma a été créé en utilisant le « STP BMN modeler» d’éclipse, que vous utiliserez plus tard.

Vous pouvez voir où le processus démarre avec le cercle vide sur la gauche, et le flux progresse vers la droite en suivant les flèches et les arcs, et se termine (à la fin :=))!) avec un cercle vide à droite.

BPMN est simplement un format XML décrivant, dans notre exemple , le modèle de la figure 1.

Il contient des « vertices» (Pluriel de « Vertex» : intersection, noeud) qui correspondent à des noeuds et des « sequenceEdges» qui correspondent à de flèches et des arcs.

Regardons un exemple: (Listing 1)

Les « Vertices» sont essentiellement des noeuds ou des tâches, représentés graphiquement dans la figure 1 par des cercles, des losanges (Têtes de diamant) et des carrés.

Dans le Listing 1, vous pouvez voir qu’ils sont identifiés, aussi, comme une liste de « outgoingEdges» et de « incommingEdges» .

Des identifiant donne simplement un ID à chaque « Vertices» qui peut être référencé comme « source» ou « target» d’un « sequenceEdge» (Représenté dans la figure 1 par des flèches directionnelles allant de « Vertices» en « Vertices» ).

L’information importante dans chaque « sequenceEdges» sont les attributs « source» et « target» qui spécifient les référence des « vertices» (noeuds) source et destination.

Remarquez que ce format de fichier n’est pas exécutable sur un moteur BPEL comme le moteur « ODE» d’apache. C’est uniquement la modélisation d’un processus métier.

Des outils existent pour transformer ces fichiers BPMN en modèle BPEL exécutable (Par exemple le projet ATL d’éclipse et un open source écrit par BABEL) .

BPEL Business Process Execution Language

BPEL est exécutable sur des moteurs comme ODE (Orchestration Director Engine) d’Apache.

LA différence entre BPEL et BPMN est que BPEL est plus structuré, étant par définition un langage d’exécution.

A la place de « Vertices» et de « SequenceEdges» , un fichier xml BPEL contient des séquences d’instruction qui incluent l’invocation de Web-Service, des opérations et des instructions comme des boucles « while’ qui peuvent exécuter une séquence de code encore et encore si une condition reste « true» .
(Voir le tag … après l’ouverture dans le listing 2) ou encore des instructions « if» et « else-if»

Dans la figure 1 (Coupe 2), il y a une instance où un arc va vers l’arrière.

C’est comme ça qu’est représenté une boucle « while» en BPMN.

Là , vous pouvez voir 2 « vertices» (noeuds) appelés while1 et while2 qui facilitent le branchement correct des processus.
(while1 a deux entrées (incomingEdges) en 1 seule sortie et while2 prend une entrée et la divise en deux sorties)

La condition de la boucle « while» est définie par « while_ok» , et si il reste « true» , la tâche (» shippingEstimator task» ) sera exécutée encore et encore.
Quand cette même condition n’est plus vraie, l’exécution s’arrête et passe à la tâche de fin (» checkout task» ).

Pour additionner, BPMN XML définit un modèle graphique de votre processus métier avec des noeuds et des graphes, et BPEL définit un modèle exécutable de votre processus métier avec des constructions exécutables comme des boucles « while» , des instructions « if» et des instructions qui appellent des opérations sur des Web-Services existants.

Le processus métier que vous allez modéliser est un simple flux permettant d’ajouter un jouet à une liste d’achat.

Les utilisateurs auront le choix d’utiliser un « shippingEstimator» (Voir la condition de la boucle while dans le listing 2), de confirmer, et de passer une commande qui pourra être rejetée ou acceptée.
Le processus devra éventuellement envoyer une facture au client et rajouter la commande dans la queue des commandes à expédier.

Pour faire cela, vous aurez à installer l’outil de développement Eclipse, avant de vous plonger dans votre « processus métier» .

Installation du projet STP (» SOA Tool Platform» ) d’eclipse

Le projet « SOA Tools Paltform» (STP) d’éclipse fournit des outils permettant la conception, la configuration, l’assemblage, le déploiement, la surveillance et la gestion de software conçu dans le cadre de SOA (Service Oriented Architecture).
STP suit les spécifications du SCA (Component Architecture Specification) .

STP comprend donc plusieurs outils (Liste non exhaustive):

STP SOA System :Outils pour l’assemblage, la construction et le deploiement de Services dans des « Container» . Avec en plus des moyens de gestion des « Policy» lors des déploiement.
STP BPEL 2 Java (B2J) Outil pour traduire BPEL en classes Java.
STP BPMN (BPMN) Outil pour éditer les diagrammes BPMN.
STP Policy Editor (POLICY) Editeur pour « WS-Policy» avec un éditeur graphique.
STP SCA (SCA) Editeur graphique pour un SCA composite.

Il est possible de télécharger l’ensemble de ces outils à l’url :

http://download.eclipse.org/stp/downloads/

( J’ai essayé de mettre à jour par l’outil update d’éclipse, ça n’a pas marché, je conseille donc de télécharger le zip « All in one» de le dezipper dans le répertoire d’eclipse.)

Section 4. Utiliser l’éditeur BPMN d’éclipse

L’éditeur STP BPMN se veut simple à utiliser et intuitif.

D’abord, nous allons apprendre à créer un diagramme BPMN pour modéliser les visiteurs achetant des jouets sur votre site web.

Puis nous apprendrons quel types d’activités que nous aurons à employer dans ce modèle.

Et finalement, vous verrez comment modéliser vos processus métier en utilisant l’éditeur BPMN

Votre premier diagramme BPMN

C’est le moment de démarrer Eclipse. Comme l’éditeur BPMN n’est pas basé sur un type de projet, vous avez juste à créer un projet générique:

Nouveau projet

Vous devriez maintenant voir le nouveau projet dans la fenêtre « Package Explorer» .

Sélectionnez le et créez un nouveau diagramme BPMN:

File > New > Other. Expand the SOA Tools folder and select Bpmn Diagram.

Clickez sur « Finish» pour créer un diagramme BPMN. Votre projet devrait ressembler à la figure ci-dessous.
Figure 6. La fenêtre Projet

Excellent!

Maintenant, vous ètes prét à manipuler quelques types d’activités. Ces eléments sont affichés sur la palette de droite.

Introduction des types d’activité

Il y a plusieurs types d’activité que vous pouvez utiliser pour modéliser votre activité métier.
Nous allons passé en revue 5 des types d’activité que vous allez utiliser.

« Empty Start» , sous « Start Events»

Cette activité démarre le processus, le cercle vide sur la gauche de la Figure 1.

Apprenez à manipuler l’éditeur: Il faut sélectioner la tache, puis clicker au centre du diagramme.

La prochaine est une tâche, comme representée dessous:

Les tâches (Task) sont des commandes comme invoquer un Web-Service.

Les deux suivantes sont une des « gateway» qui permettent à un processus de se diviser en 2 directions différentes, exclusivement ou en parallèles.

D’abord est la « exclusive data-based gateway» .

Vous comprendrez comment ca marche plus tard. En bref, c’est utilisé pour branché le processus métier vers 2 chemins différents,un pour le cas où la commande est un echec, et l’autre si la commande a été un succes.

Maintenant regardon la « parallel gateway» .

Vous pouvez utiliser ce « gateway» pour définir 2 tâches qui seront exécutées en parallèle, comme par exemple envoyé une facture au client et envoyé un ordre d’envoi au service des expéditions après une commande réussie.

La dernière activité à rajouter est la « Empty End Event» , un évènement qui termine le processus.

Cela correspond au cercle vide sur la droite de la figure 1, terminant le processus.

Créer le processus metier

Maintenant il faut modéliser le processus métier.

Pour commencer , clicker sur le « Empty Start Activity» . Puis « double-click» et appelé cette activité « start» par exemple.

Clicker sur l’activité de type « task» , la placer à la droite de cercle « start» , « double-click» et l’appelé « addToyToCart» .

Maintenant, nous allons créer un nouvel arc depuis le cercle « start» jusqu’à la tâche « addToyToCart» .

Plcer le curseur sur la bordure droite du cercle « start» jusqu’à ce que 2 petites flèches apparaissent à sa droite.Clicker sur le petit carré à l’extrémité de la flèche pleine.
L’étirer jusqu’à la tâche « addToyToCart» jusqu’à ce qu’une flèche sombre apparaisse à sa droite.

Relacher la souris, et un nouveau lien devrait relier les 2 activités, comme ci-dessous:

Bien, vous avez créé votre premier arc. Votre « business process» commence à prendre forme.

Avec l’aide de la figure 1, vous devez être capable de créer de nouvelles tâches.

Remarquez que vous pouvez donner un nom aux arcs, ce qui donne encore plus de clarté au shéma.

Une fois terminé, vous pouvez examiner le résultat en BPMN correspondant à votre diagramme en regardant le fichier .bpmn.

Vous pouvez voir les « vertices» et les « sequenceEdges» qui décrivent le « business process» que vous avez modelés.

Félicitations ! Vous avez réussi à modéliser un « Business Process» en utilisant le « BPMN modeler» .

Maintenant, il vous reste à convertir le BPMN en BPEL, et à déployer le BPEL sur un moteur BPEL (Ode d’Apache par exemple) . Ce sera peut-être l’objet de prochains tutoriels . Quand pensez-vous?

SOA et SCA: Le Projet Apache Tuscany 0

Posted mai 4, 2008

Le projet Tuscany a pour but de créer une infrastructure SOA.

Tuscany est basé sur les spécifications définis par l’» Open CSA» .

SCA (Service Component Architecture) définit un modèle simple à base de service permettant la construction , l’assemblage et le déployment de services (Existant et nouveau) et de façon indépendante des languages et technologies.

SDO (Service Data Object) fournit une interface pour manipuler les différentes formes de données, y compris des documents XML, qui peuvent exister dans un réseau de Services eet fournit les mécanismes pour des conversions.

Première Application Tuscany

Ce tutorial est inspiré (traduit ?) de getting started with tuscany

Etape 1 : Telecharger java, tuscany et maven

Téléchargement: « Tuscany Java SCA release« .

Construire le « Calulator» en java

Cet exemple illustre comment définir votre application en restant concentré sur la logique métier. Il vous ammene à travers les étapes de la construction d’un « Calculator» . Toutes les connections entre les « Components» à l’intérieur du « Composite» sont locales et décrires en utilisant des Interfaces Java.

Etape 0 – Obtenir les librairies nécessaires

Pour cela il faut utiliser maven.

voila le 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>0.0.0</modelVersion>
<groupId>com.bg.soa.test</groupId>
<artifactId>bg_soa_test_tutos_tuscany</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>bg_soa_test_tutos_tuscany</name>
<url>http://maven.apache.org</url>
<repositories>
<repository>
<id>apache.incubator</id>
<url>http://people.apache.org/repo/m2-incubating-repository</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-host-embedded</artifactId>
<version>1.2-incubating</version>
</dependency>
<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-java-runtime</artifactId>
<version>1.2-incubating</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-ws-axis2</artifactId>
<version>1.2-incubating</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-host-tomcat</artifactId>
<version>1.2-incubating</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Si vous travaillé avec eclipse, placé ce fichier à la racine de votre projet, puis tapez:

mvn eclipse:eclipse

Etape 1 – Définir quels sont les blocs nécessaires.

Réflechissez à comment votre application peut être divisé en petites fonctions et/ou services.Chaque bloc est une unité logique d’opération qui peut être utilisée dans une application englobante. Pour notre exemple, le « Calculator» sera divisé en 5 blocs: AddService bloc, SubstractService bloc, MultiplyService bloc, DivideService bloc et un bloc principal qui accepte des requètes et les route vers le service approprié.Nous appelerons ce bloc « CalculatorService» .

Etape 2 – Implémenter chaque bloc

Maintenat que vous avez identifié les blocs de fonctionnalité de votre application, vous ètes prét pour les créer.

En SCA chaque bloc de fonctionnalité est appelé un « Component» . Aussi regardons comment on implémente un « Component» .

Nous prendrons comme premier exemple le bloc – ou « Component» – AddService .

Le « Component» AddService fournira un service qui additionne 2 nombres l’un à l’autre.Le « Component» CalculatorService utilise le « Component» AddService à chaque fois qu’on lui demande de faire une addition.

Si nous devions écrire le « Component» AddService en Java classique, nous pourrions commencer par décrire une Interface Java.

package com.bg.soa.tuscany.calculator;
public interface AddService {
double add(double n1, double n2);
}

Maintenant , nous fournissons une implementation de cette interface.

package com.bg.soa.tuscany.calculator;
public class AddServiceImpl implements AddService {
@Override
public double add(double n1, double n2) {
return n1+n2;
}
}

Mais Attend! On est en train d’écrire un « Component SCA» ? Ca doit être plus compliqué qu’une interface et son implementation, non ? Bon, en fait, un SCA « Component» peut être écrit en Java classique, c’est ce que nous avons fait.

Nous pouvons utiliser SCA pour exposer ce service que fournit le « Component» addService à d’autres acteurs, par exemple des Web-Services, JMS ou RMI, sans changer une ligne de code à l’implémentation de AddService.

Regardons le « Component» CalculatorService. Il est interessantparcequ’il va devoir appelé le « Component» AddService.

Dans l’application finale, il aura aussi à appeler les « Component» SubstracService, MultiplyService et DivideService.

A nouveau, nous commencerons par définir une interface parceque CalculatoService doit lui-même fournir une interface que d’autres appelleront.

package com.bg.soa.tuscany.calculator;
public interface CalculatorService {
double multiply(double n1, double n2);
double add(double n1, double n2);
double substract(double n1, double n2);
double divide(double n1, double n2);
}

Maintenant, nous implementons cette interface:

package com.bg.soa.tuscany.calculator;
import org.osoa.sca.annotations.Reference;
public class CalculatorServiceImpl implements CalculatorService {
private AddService addService;
private SubtractService subtractService;
private MultiplyService multiplyService;
private DivideService divideService;
@Reference
public void setAddService(AddService addService) {
this.addService = addService;
}
... methodes set pour les autres attributs à rajouter
public double add(double n1, double n2) {
return addService.add(n1, n2);
}
...implementation des autre méthodes définies dans l'interface ici.
}

On aura remarqué l’annotation « @Reference» .

Nous avons maintenant quelques « Components» implémenté en Java.Chaque « Component» a une interface bien définie, utilisant java dans notre exemple.

Step 3 – Assembler l’application:

Tout est parfait, mais comment exécuter ces deux « Components» . Oui bien sûr, le programmeur java qui est en nous veut foncer, écrire les lignes permettant de connecter nos deux « Components» ensemble et de les éxecuter. On pourrait le faire facilement dans notre cas:

public class CalculatorClient {
public static void main(String[] args) throws Exception {
CalculatorServiceImpl calculatorService = new CalculatorServiceImpl();
AddService addService = new AddServiceImpl();
calculatorService.setAddService(addService);
System.out.println("3 + 2=" + calculatorService.add(3, 2));
//appeler les autres methodes ici, si nous avons implementé SubtractService, MultiplyService, DivideService
}
}

Mais cela n’utilise pas Tuscany SCA, et étendre ce code pour implementer un Web-Srvice par exemple ne serait pas simple.

En premier, changeons le code pour appeler le « Tuscany SCA runtime» avant d’appeler nos « Components» .

package com.bg.soa.tuscany.calculator;
import org.apache.tuscany.sca.host.embedded.SCADomain;
public class MainApp {
static boolean isOn =true;
public static void main(String[] args) throws Exception{
SCADomain scaDomain = SCADomain.newInstance("Calculator.composite");
CalculatorService calculatorService = scaDomain.getService(CalculatorService.class, "CalculatorServiceComponent");
System.out.println("3 + 2 = " + calculatorService.add(3, 2));
while(true) Thread.sleep(10000);
}
}

Vous pouvez voir que nous commençons par utiliser une méthode static pour obtenir une instance de SCADomain.

Le SCADomain est un concept en SCA qui represente les frontières d’un sysème SCA.
Il pourrait être distribué entre plusieurs processeurs.
Pour l’instant, regardons comment cela fonctionne à l’intérieur d’une seule JVM.

Le paramètre « Calculator.composite» fait référence à un fichier xml qui décrit comment les components dans l’application « Calculator» sont assemblés.

Voilà le XML à l’intérieur de ce fichier « Calculator.composite» qui est dans le classpath.

la dernière ligne est là pour empécher la JVM de s’arrêter. Nous verrons plus loin (Quand nos exposerons des WS par exemple) à quoi cela servira.

<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" name="Calculator">
<component name="CalculatorServiceComponent">
<implementation.java class="com.bg.soa.tuscany.calculator.CalculatorServiceImpl"/>
<reference name="addService" target="AddServiceComponent" />
</component>
<component name="AddServiceComponent">
<implementation.java class="com.bg.soa.tuscany.calculator.AddServiceImpl"/>
</component>
</composite>

Vous pouvez observer que nous avons défini 2 « components» et spécifié les classes Java implémentant ces « components» que Tuscany SCA a besoin de charger.
Ce sont les classes que nous avons juste implémentées.

Remaquez aussi que le « CalculatorServiceComponent» a une référence nommée « addService» .

Dans le XML, cette référence correspond au « AddServiceComponent» .
Ce n’est pas une coincidence que le nom de la référence « addService» corresponde au nom du champs addService que nous avons créé quand nous avons implémenté « CalculatorServiceImpl» .

Le moteur « Tuscany SCA» parse les informations du fichier XML et les utilise pour construire les objets et leurs relations qui représente notre application « Calculator» .
Il crée en premiet des instances de AddServiceImpl et CalculatorServiceImpl.
Il injecte ensuite une référence de l’objet AddServiceImpl dans le champs addService de l’objet CalculatorServiceImpl.
Si vous regardez à nouveau comment nous avons implémenté le CalculatorService, vous remarquerez une annotation @Reference qui dit à SCA quel champs sont à référencé.

C’est equivalent à ce bout de code pour un clent java habituel:

CalculatorServiceImpl calculatorService = new CalculatorServiceImpl();
AddService addService = new AddServiceImpl();
calculatorService.setAddService(addService);

Une fois que le fichier composite est chargé dans le SCADomain, notre client demande au SCADomain de nous donner une référence vers le component appelé « CalculatorServiceComponent» .

CalculatorService calculatorService = scaDomain.getService(CalculatorService.class, "CalculatorServiceComponent");

Nous pouvons utiliser cette référence pour accéder aux méthodes que nous avons créées, ici par exemple, la méthode CalculatorServiceImpl.add().

Les spécifications SCA décrive souvent les applications SCA sous forme de diagramme.
Cela aide souvent quels sont les components qui composent une application et comment ils sont cablés ensemble.
Si nous traçons un diagramme de ce que nous avons construit dans notre exemple, nous obtenons quelquechose comme la figure suivante:

Step 4 – Déployer l’application:

Si le fichier « Calculator.composite» est dans notre class-path, ainsi que les autres librairies (les .jar), nous pouvons éxécuter notre exemple.

Nous proposons ici un exemple de fichier ant permettant la compilation et l’execution.

Il faut bien sûr adapter les properties tuscanyHome …

On peut remarquer que la liste des librairies (des jar) est définie dans le manifest du tuscany-sca-manifest.jar . Ce jar est livré uniquement avec le binaire de tuscany (Pas avec les sources).

<project name="sample-calculator-webapp" default="compile">
<property name="tuscanyHome" location="C:\java\tuscany-sca-1.2-incubating" />
<property name="test.class" value="com.bg.soa.tuscany.calculator.MainApp" />
<property name="test.jar" value="bg-sample-calculator.jar" />
<target name="init">
<mkdir dir="target/classes" />
<mkdir dir="src/main/resources" />
</target>
<target name="compile" depends="init">
<javac srcdir="src/main/java" destdir="target/classes" debug="on" source="1.5" target="1.5">
<classpath>
<pathelement location="${tuscanyHome}/lib/tuscany-sca-manifest.jar" />
</classpath>
</javac>
<copy todir="target/classes">
<fileset dir="src/main/resources" />
</copy>
<jar destfile="target/${test.jar}" basedir="target/classes">
<manifest>
<attribute name="Main-Class" value="${test.class}" />
</manifest>
</jar>
</target>
<target name="run-classes">
<java classname="${test.class}" fork="true">
<classpath>
<pathelement path="target/classes" />
<pathelement location="${tuscanyHome}/lib/tuscany-sca-manifest.jar" />
</classpath>
</java>
</target>
<target name="run">
<java classname="${test.class}" fork="true">
<classpath>
<pathelement path="target/${test.jar}" />
<pathelement location="${tuscanyHome}/lib/tuscany-sca-manifest.jar" />
</classpath>
</java>
</target>
<target name="clean">
<delete quiet="true" includeemptydirs="true">
<fileset dir="target" />
</delete>
</target>
</project>

Utiliser d’autres configurations

En regardant en arrière, l’application « Calculator» construite en utilisant le « Tuscany SCA» n’est rien de plus qu’une application java ordinaire.
Cependant, nous avons un fichier xml « Composite» qui décrit comment notre application est assemblée.

Cette notion d’ assemblage est importante et apporte de nombreux avantage si notre application devient plus complexe et que nous voulons la modifier, ou intégrer d’autres components, sans se soucier du langage dans lequel ils sont écrits.

Maintenant , disons que notre « Calculator» est devenu populaire que nous voulons la mettre sur l’intranet de la société et la rendre acessible depuis les browser d’applications Web2.0.
C’est ce que nous cherchons depuis le début.Comme nous avons un fichier XML qui décrit notre application, cela devient facile avec « Tuscany SCA» .

Ce qui suit devrait faire l’affaire:

<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" name="Calculator">
<service name="CalculatorService" promote="CalculatorServiceComponent">
<interface.java interface="com.bg.soa.tuscany.calculator.CalculatorService"/>
<binding.ws uri="http://localhost:8181/CalculatorService"/>
</service>
<component name="CalculatorServiceComponent">
<implementation.java class="com.bg.soa.tuscany.calculator.CalculatorServiceImpl"/>
<reference name="addService" target="AddServiceComponent" />
</component>
<component name="AddServiceComponent">
<implementation.java class="com.bg.soa.tuscany.calculator.AddServiceImpl"/>
</component>
</composite>

Tout ce que nous avons fait, c’est rajouter le tag <service> qui indique à Tuscany comment exposer notre « CalculatorService» .

Nous n’avons pas modifier une ligne du code!

Pour tester, il faut prendre un browser et aller à l’adresse indiquée:
http://localhost:8181/CalculatorService?wsdl

Remarque: Lors de l’éxécution, vous pouvez avoir le message d’erreur suivant :Address already in use: Une autre application ecoute sur ce port. Cela peut être la même application que vous avez re-lancé.

Si nous voulons exposer le service en JSON, il faut modifier le service comme suit:

<service name="CalculatorService" promote="CalculatorServiceComponent">
<interface.java interface="com.bg.soa.tuscany.calculator.CalculatorService"/>
<binding.ws uri="http://localhost:8181/CalculatorService"/>
<binding.jsonrpc/>
</service>

Comme je ne suis pas à l’aise avec cette techno (JSON) , je ne l’ai pas testé!

Exposer le service en RMI, …

Il faudrait au niveau du service rajouter le tag suivant:

<tuscany:binding.rmi host="localhost" port="8099" serviceName="CalculatorRMIService"/>

Rajouter un « Component» en script ruby, python, javascript, groovy ..

Il faut rajouter les dépendances suivantes dans le fichier POM.xml (Ou dans le classpath lors de l’execution)

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-script</artifactId>
<version>1.2-incubating</version>
<scope>runtime</scope>
</dependency>

Et dans le fichier .composite, il faut rajouter un « Component» :

<component name="SubstractServiceComponent">
<tuscany:implementation.script script="com/bg/soa/tuscany/calculator/SubtractServiceImpl.rb"/>
</component>

voilà le fichier composite complet:

<?xml version="1.0" encoding="UTF-8"?>
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0" name="Calculator">
<service name="CalculatorService" promote="CalculatorServiceComponent">
<interface.java interface="com.bg.soa.tuscany.calculator.CalculatorService"/>
<binding.ws uri="http://localhost:8183/CalculatorService"/>
</service>
<component name="CalculatorServiceComponent">
<implementation.java class="com.bg.soa.tuscany.calculator.CalculatorServiceImpl"/>
<reference name="addService" target="AddServiceComponent" />
<reference name="substractService" target="SubstractServiceComponent" />
</component>
<component name="AddServiceComponent">
<implementation.java class="com.bg.soa.tuscany.calculator.AddServiceImpl"/>
</component>
<component name="SubstractServiceComponent">
<tuscany:implementation.script script="com/bg/soa/tuscany/calculator/SubtractServiceImpl.rb"/>
</component>
</composite>

Il ne faut pas oublier de reférencer ce « Component» lors de la définition du « Component» CalculatorServiceComponent, ainsi que de rajouter un xmlns:tuscany.

Et bien sur il faut definir le script dans le fichier SubtractServiceImpl.rb

def substract(n1, n2)
return n1 - n2
end

Conclusion

Vous venez d’avoir un apercu de la puissance des SOA: Collaboration entre services, entre plusieurs protocoles, plusieurs technologies.
Et il y encore plus: Les « Policies» (Gestion des droits des services), la répartition des applications sur plusieurs serveurs, l’orchestration de services, le déploiement de tuscany sur Tomcat …
C’est relativement simple à mettre en oeuvre (Beaucoup plus simple que J2EE 2.3 !) Il y a de quoi s’enthousiasmer.
Qu’en pensez vous ?

Comment choisir un Enterprise Service Bus (ESB) ? 0

Posted mai 3, 2008

Traduction de servicemix faq Servicemix est un projet Apache proposant un ESB (Enterprise Service Bus),un SCA (Service Component Application) et un JBI (Java Business Integration).

Devant les besoins d’intégration d’un middleware , il est logique de considérer l’adoption d’un ESB. En faisant les évaluations des logiciels, il est important d’approcher le choses de manière à ce que vos exigences soient l’instrument central du processus. Il y a habituellement deux niveaux d’évaluation qui doivent être considérés lors de l’adoption de n’importe quel software : vos besoins métiers et les fonctionnalités du logiciel (Ici de l’ESB). Il y a de nombreux points dans ces 2 niveaux, et nous allons les passer en revue.

Votre objectif métier

Ne dites pas que votre objectif métier c’est le SOA. C’est le comment, pas le pourquoi. SOA n’est qu’une façon de penser l’architecture logicielle. Votre objectif métier c’est le but que vous essayez d’atteindre dans votre activité à travers l’usage du logiciel que vous êtes en train de mettre en place. Voilà un exemple:

Notre objectif métier est de combiner des données météo avec des cartes pour fournir aux clients des prévisions météo immédiates pour leurs destinations quand ils font des réservations de voyage sur notre portail.
Cela facilite non seulement les projets de voyage, mais aussi permet à notre système d’annonces publicitaire de mieux cibler les clients . Cela apportera un plus à nos clients, mais permettra de mieux cibler les publicités pour tenter d’augmenter le taux de conversions (clics sur annonces).

Remarquez que l’objectif métier est concentré sur le but du logiciel du point de vue métier. Le but est de:

Améliorer l’expérience des clients grâce à l’usage de cartes et de météo
Augmenter le taux de conversion des annonces publicitaires

Comprendre vos objectifs métiers vous met en meilleure position pour définir des exigences fonctionnelles pour atteindre cet objectif.

Vos exigences fonctionnelles

Une fois compris les objectifs métiers du projet, passons aux exigences fonctionnelles. Ci dessous sont listés quelques exemples d’exigences fonctionnelles pour notre objectif métier:

Fournir un accès aux données météo
- Cela demande l’intégration d’un socket pour récupérer les données
- Il faudra parser les données
Fournir un accès aux données géographiques, aux cartes
- Google offre une API (Google Map API ) pour accéder à ces données
Créer un « overlay» permettant d’intégrer les cartes et la météo sur les destinations des clients
En combinant les prévisions et les destinations , donner des règles au système fournissant les publicités pour adapter les annonces aux destinations et aux prévisions météo
Si le client clicke sur une annonce, sauvegarder cette information en base de donnée et la lier au profil du client. Cela améliorera nos prédictions lorsque le client reviendra une autre fois.

Ces exigences fonctionnelles augmentent dramatiquement lorsque l’objectif métier est identifié et clairement communiqué à toutes les personnes concernées dans le projet. De telles exigences vont amener les choix d’architecture du système et du logiciel.

Vos choix d’architecture

Avant de commencer à contacter des fournisseurs, il est important d’établir quelques choix d’architecture. Ces choix ne sont pas gravés dans le marbre. Cela peut inclure de concevoir le système d’une façon « Orientée Service» , d’utiliser certains packages, et peut être le hardware et les softs de test. Vous avez peut être fait ces choix de façon implicite à travers vos expériences précédentes. Si il en est ainsi, il est important d’identifier et de communiquer ces décisions explicitement aux différentes parties-prenantes pour qu’il y ait un certain niveau de clarté dans le groupe.

En travaillant à travers ces exercices, vous devriez avoir non seulement un ensemble de solutions à partager, mais vous aurez aussi vos critères d’évaluation d’un ESB.

Vos critère pour évaluer un ESB

N’importe quelle évaluation de software demande la connaissance des sujets discutés plus haut. Sans une bonne maîtrise de ces sujets, il est difficile d’évaluer la capacité d’un logiciel d’atteindre des buts spécifiques.

Il est important aussi de ne pas comparer les solutions logicielles fonction par fonction. Cette méthode d’évaluation ne donne une image quand au but attendu du logiciel.

Par exemple:

Quelle importance si un logiciel A affirme fournir des accès sécurisés vers des ressources X, mais que son API est vraiment compliqué à utiliser ?

Quelle importance si un logiciel B annonce fonctions 1, 2 et 3 mais que ses performances sont déplorables ?

Une expérience personnelle avec un logiciel donné dans votre environnement est une priorité. Quand on parle d’ESB, c’est encore plus critique parce que l’ESB contrôle l’intégration du système et que deux scénarios d’intégration ne sont jamais identiques. Déployer un ESB dans votre environnement pour résoudre un ou deux de vos problèmes par une validation de conception vous donnera bien plus d’informations et de conclusions que n’importe quelles comparaisons sur papier.

SOA : Service Oriented Architecture 0

Posted mai 2, 2008

Le but des SOA: Unifier des systèmes hétérogènes, permettre une certaine « agilité» à des systèmes répartis, accélérer les vitesses de développement et de déploiement, offrir (ou utiliser) des services à (de) partenaires (Cela s’appelle l’interopérabilité).

Les moyens:
Des services sont fournis (En général des web-services) , s’appuyant sur les normes les plus répandues (http, xml, soap, wsdl) . Toute les informations necessaires pour invoquer un service sont décrites dans un contrat: le wsdl.

Plusieurs normes et outils sont apparus pour manipuler ces services:
BPEL (Business Process Execution Langage) permet de composer des services à partir d’autres services. Cela est très puissant … mais a aussi des limites.

Plusieurs solutions sont apparues autour de ces concepts:
1 – JBI « Java Business Integration» Spécifié la JSR 208 de la JCP (Java Community Process),
2 – ESB « Enterprise Service Bus» ,
3 – SCA « Service Component Architecture» Spécifié par l’OASIS.

Qu’est ce qu’il faut en penser? Que choisir ? Que faut-il éliminer? Quelles sont leurs différences ? Leurs points communs ? Lesquels survivront dans 5 ans? Dans 1 ans?
Les spécifs, c’est clair, sont quasiment illisibles (230 pages pour JBI, J’ai arrêté l’impression de la première specif du SCA (Assembly Model Spécification) à 80 pages et ainsi de suite …).
Les experts (Mais qui sont ils ???? ) , sont tous suspects de partialité, défendent leurs crèmeries ou leurs prestations…

Restons pragmatique : Au bout du compte, ce sera un produit, un serveur, une application distribuée ou non. Essayons de faire le tour de ce qui existe …
Au secours! Quoi faire ? Quels critères sélectionnés?

Nom	SCA	JBI	ESB	Version
swordfish	***	***	***	Sortie Imminente
Mule	***	***	*****	-
Tuscany	*****	-	-	1.2
open-esb		*****	*****	2.0
petals	*****	*****	*****	2.1.2
servicemix	*****	*****	*****	4.0
WebSphere	-	-	-	-
fabric3	*****	*	*	0.5 Alpha2 Release
Newton	*****	*	*	1.2
HydraSCA	******	*	*	-
Weblogic	*****	*	*	-
Oracle	*****	*	*	-
covansys	*****	*	*	-

Comment choisir ?

Page suivante »

Feeds

Monthly Archives

Categories

REST: REpresentationnal State Transfer

Style d’architecture RESTful

Un bon exemple vaut mieux qu’un long discour

wadl : Web Application Description Language

Liste des ressources

REST et java

REST et netbeans

Ecrire un xsd (un schema)

Ecrire un wsdl

Créer un bpel

Déployer et tester le projet sur le serveur

ressources

JBI Components

Créer un SA (Service Assembly)

Créer un projet

Créer un projet SU (Service Unit) avec Maven et l’archetype « servicemix-service-unit»

Configurer le xbean.xml

Créer le SA (» Service Assembly» ) avec Maven et l’archetype « servicemix-service-assembly»

Déployer le SA

Tester le SA

Rajouter 2 SU

JBI Components

« Binding Components»

JBI Components

Vocabulaire

Structure d’un wsdl

WSDL « portType»

Messages WSDL

Operation Types

Outil / editeur

BPEL Business Process Execution Language

Installation du projet STP (» SOA Tool Platform» ) d’eclipse

Section 4. Utiliser l’éditeur BPMN d’éclipse

Votre premier diagramme BPMN

Introduction des types d’activité

Créer le processus metier

Première Application Tuscany

Etape 1 : Telecharger java, tuscany et maven

Construire le « Calulator» en java

Etape 0 – Obtenir les librairies nécessaires

Etape 1 – Définir quels sont les blocs nécessaires.

Etape 2 – Implémenter chaque bloc

Step 3 – Assembler l’application:

Step 4 – Déployer l’application:

Utiliser d’autres configurations

Exposer le service en RMI, …

Rajouter un « Component» en script ruby, python, javascript, groovy ..

Conclusion

Votre objectif métier

Vos exigences fonctionnelles

Vos choix d’architecture

Vos critère pour évaluer un ESB