Archive for the 'sca' Category


Sercices Oriented Architecture: Les outils et ressources de base 0

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 – Java Business Integration: C’est quoi ? 0

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é :D 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

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

  1.  
  2. <definitions>
  3. <types>
  4.    definition des types........
  5. </types>
  6.  
  7. <message>
  8.    definition des messages ....
  9. </message>
  10. <portType>
  11.    definition des ports (opérations et messages).......
  12. </portType>
  13.  
  14. <binding>
  15.    Les protocoles de communication utilisés par le web-service
  16. </binding>
  17. <service>
  18.    Une adresse physique où accéder au service.
  19. </service>
  20. </definitions>
  21.  

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.

wsdl_1

BPMN – Business Process Modeling Notation 1

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.

figure 5

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

figure 6

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» 

figure 7

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:

figure 8

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

figure 9

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

figure 10

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.

figure 11

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.

figure 12

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

figure 13

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.

figure 14

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

figure 15

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

figure 16

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

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:

  1.  
  2. <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">
  3.     <modelVersion>0.0.0</modelVersion>
  4.     <groupId>com.bg.soa.test</groupId>
  5.     <artifactId>bg_soa_test_tutos_tuscany</artifactId>
  6. <packaging>jar</packaging>
  7.     <version>1.0-SNAPSHOT</version>
  8.     <name>bg_soa_test_tutos_tuscany</name>
  9.     <url>http://maven.apache.org</url>
  10.  
  11.     <repositories>
  12.         <repository>
  13.             <id>apache.incubator</id>
  14.             <url>http://people.apache.org/repo/m2-incubating-repository</url>
  15.         </repository>
  16.     </repositories>
  17.  
  18.     <dependencies>
  19.  
  20.         <dependency>
  21.             <groupId>org.apache.tuscany.sca</groupId>
  22.             <artifactId>tuscany-host-embedded</artifactId>
  23.             <version>1.2-incubating</version>
  24.         </dependency>
  25.  
  26.         <dependency>
  27.             <groupId>org.apache.tuscany.sca</groupId>
  28.             <artifactId>tuscany-implementation-java-runtime</artifactId>
  29.             <version>1.2-incubating</version>
  30.             <scope>runtime</scope>
  31.         </dependency>
  32.  
  33.          <dependency>
  34.             <groupId>org.apache.tuscany.sca</groupId>
  35.             <artifactId>tuscany-binding-ws-axis2</artifactId>
  36.             <version>1.2-incubating</version>
  37.             <scope>runtime</scope>
  38.         </dependency>
  39.  
  40.         <dependency>
  41.             <groupId>org.apache.tuscany.sca</groupId>
  42.             <artifactId>tuscany-host-tomcat</artifactId>
  43.             <version>1.2-incubating</version>
  44.             <scope>runtime</scope>
  45.         </dependency>   
  46.  
  47.         <dependency>
  48.             <groupId>junit</groupId>
  49.             <artifactId>junit</artifactId>
  50.             <version>3.8.1</version>
  51.             <scope>test</scope>
  52.         </dependency>
  53.     </dependencies>
  54. </project>
  55.  

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

  1.  
  2. mvn eclipse:eclipse
  3.  

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.

  1.  
  2. package com.bg.soa.tuscany.calculator;
  3.  
  4. public interface AddService {
  5.  
  6.     double add(double n1, double n2);
  7.  
  8. }
  9.  

Maintenant , nous fournissons une implementation de cette interface.

  1.  
  2. package com.bg.soa.tuscany.calculator;
  3.  
  4. public class AddServiceImpl implements AddService {
  5.  
  6.     @Override
  7.     public double add(double n1, double n2) {
  8.         return n1+n2;
  9.     }
  10. }
  11.  

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.

  1.  
  2. package com.bg.soa.tuscany.calculator;
  3.  
  4. public interface CalculatorService {
  5.  
  6.     double multiply(double n1, double n2);
  7.     double add(double n1, double n2);
  8.     double substract(double n1, double n2);
  9.     double divide(double n1, double n2);
  10.  
  11. }
  12.  

Maintenant, nous implementons cette interface:

  1.  
  2. package com.bg.soa.tuscany.calculator;
  3.  
  4. import org.osoa.sca.annotations.Reference;
  5.  
  6. public class CalculatorServiceImpl implements CalculatorService {
  7.  
  8.     private AddService addService;
  9.     private SubtractService subtractService;
  10.     private MultiplyService multiplyService;
  11.     private DivideService divideService;
  12.  
  13.     @Reference
  14.     public void setAddService(AddService addService) {
  15.         this.addService = addService;
  16.     }
  17.  
  18.     ... methodes set pour les autres attributs à rajouter
  19.  
  20.     public double add(double n1, double n2) {
  21.         return addService.add(n1, n2);
  22.     }
  23.  
  24.     ...implementation des autre méthodes définies dans l'interface ici.
  25. }
  26.  

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:

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

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

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

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.

  1.  
  2. <composite xmlns="http://www.osoa.org/xmlns/sca/1.0"  name="Calculator">
  3.  
  4.     <component name="CalculatorServiceComponent">
  5.         <implementation.java class="com.bg.soa.tuscany.calculator.CalculatorServiceImpl"/>
  6.         <reference name="addService" target="AddServiceComponent" />
  7.         <!-- references a SubtractComponent, MultiplyComponent et DivideComponent  -->
  8.     </component>
  9.  
  10.     <component name="AddServiceComponent">
  11.         <implementation.java class="com.bg.soa.tuscany.calculator.AddServiceImpl"/>
  12.     </component>
  13.  
  14.     <!-- definitions de SubtractComponent, MultiplyComponent et DivideComponent -->
  15.  
  16. </composite>
  17.  

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:

  1.  
  2.         CalculatorServiceImpl calculatorService = new CalculatorServiceImpl();
  3.         AddService            addService        = new AddServiceImpl();
  4.         calculatorService.setAddService(addService);
  5.  



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

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

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

  1.  
  2. <project name="sample-calculator-webapp" default="compile">
  3. <property name="tuscanyHome" location="C:\java\tuscany-sca-1.2-incubating" />
  4. <property name="test.class" value="com.bg.soa.tuscany.calculator.MainApp" />
  5. <property name="test.jar" value="bg-sample-calculator.jar" />
  6.  
  7.     <target name="init">
  8.         <mkdir dir="target/classes" />
  9.         <mkdir dir="src/main/resources" />
  10.     </target>
  11.  
  12.     <target name="compile" depends="init">
  13.         <javac srcdir="src/main/java" destdir="target/classes" debug="on" source="1.5" target="1.5">
  14.             <classpath>
  15. <pathelement location="${tuscanyHome}/lib/tuscany-sca-manifest.jar" />
  16.             </classpath>
  17.         </javac>
  18.         <copy todir="target/classes">
  19.             <fileset dir="src/main/resources" />
  20.         </copy>
  21.         <jar destfile="target/${test.jar}" basedir="target/classes">
  22.             <manifest>
  23.                 <attribute name="Main-Class" value="${test.class}" />
  24.             </manifest>
  25.         </jar>
  26.     </target>
  27.  
  28.     <target name="run-classes">
  29.         <java classname="${test.class}" fork="true">
  30.             <classpath>
  31. <pathelement path="target/classes" />
  32. <pathelement location="${tuscanyHome}/lib/tuscany-sca-manifest.jar" />
  33.             </classpath>
  34.         </java>
  35.     </target>
  36.  
  37.     <target name="run">
  38.         <java classname="${test.class}" fork="true">
  39.             <classpath>
  40. <pathelement path="target/${test.jar}" />
  41. <pathelement location="${tuscanyHome}/lib/tuscany-sca-manifest.jar" />
  42.             </classpath>
  43.         </java>
  44.     </target>
  45.  
  46.     <target name="clean">
  47.         <delete quiet="true" includeemptydirs="true">
  48.             <fileset dir="target" />
  49.         </delete>
  50.     </target>
  51. </project>
  52.  

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:

  1.  
  2. <composite xmlns="http://www.osoa.org/xmlns/sca/1.0"  name="Calculator">
  3.  
  4.      <service name="CalculatorService" promote="CalculatorServiceComponent">
  5.          <interface.java interface="com.bg.soa.tuscany.calculator.CalculatorService"/>
  6.          <binding.ws uri="http://localhost:8181/CalculatorService"/>
  7.      </service>   
  8.  
  9.     <component name="CalculatorServiceComponent">
  10.         <implementation.java class="com.bg.soa.tuscany.calculator.CalculatorServiceImpl"/>
  11.         <reference name="addService" target="AddServiceComponent" />
  12.         <!-- references to SubtractComponent, MultiplyComponent and DivideComponent  -->
  13.     </component>
  14.  
  15.     <component name="AddServiceComponent">
  16.         <implementation.java class="com.bg.soa.tuscany.calculator.AddServiceImpl"/>
  17.     </component>
  18.  
  19.     <!-- definitions de SubtractComponent, MultiplyComponent and DivideComponent -->
  20.  
  21. </composite>
  22.  

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:

  1.  
  2.      <service name="CalculatorService" promote="CalculatorServiceComponent">
  3.          <interface.java interface="com.bg.soa.tuscany.calculator.CalculatorService"/>
  4.          <binding.ws uri="http://localhost:8181/CalculatorService"/>
  5.          <binding.jsonrpc/>
  6.      </service>
  7.  



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:

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

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)

  1.  
  2.         <dependency>
  3.             <groupId>org.apache.tuscany.sca</groupId>
  4.             <artifactId>tuscany-implementation-script</artifactId>
  5.             <version>1.2-incubating</version>
  6.             <scope>runtime</scope>
  7.         </dependency>
  8.  

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

  1.  
  2.     <component name="SubstractServiceComponent">
  3.         <tuscany:implementation.script script="com/bg/soa/tuscany/calculator/SubtractServiceImpl.rb"/>
  4.     </component>
  5.  

voilà le fichier composite complet:

  1.  
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <composite xmlns="http://www.osoa.org/xmlns/sca/1.0" xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0" name="Calculator">
  4.  
  5.      <service name="CalculatorService" promote="CalculatorServiceComponent">
  6.          <interface.java interface="com.bg.soa.tuscany.calculator.CalculatorService"/>
  7.          <binding.ws uri="http://localhost:8183/CalculatorService"/>
  8.      </service>   
  9.  
  10.     <component name="CalculatorServiceComponent">
  11.         <implementation.java class="com.bg.soa.tuscany.calculator.CalculatorServiceImpl"/>
  12.         <reference name="addService" target="AddServiceComponent" />
  13.         <reference name="substractService" target="SubstractServiceComponent" />
  14.     </component>
  15.  
  16.     <component name="AddServiceComponent">
  17.         <implementation.java class="com.bg.soa.tuscany.calculator.AddServiceImpl"/>
  18.     </component>
  19.  
  20.     <component name="SubstractServiceComponent">
  21.         <tuscany:implementation.script script="com/bg/soa/tuscany/calculator/SubtractServiceImpl.rb"/>
  22.     </component>
  23.  
  24. </composite>
  25.  



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

  1.  
  2. def substract(n1, n2)
  3.     return n1 - n2
  4. end
  5.  


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 ?