WebSphere Enterprise Service Bus, Version 6.2.0 Systèmes d'exploitation: AIX, HP-UX, i5/OS, Linux, Solaris, Windows


Architecture de composants de service

L'architecture SCA est un concept que vous pouvez implémenter de différentes manières. Elle n'exige aucune technologie, langage de programmation, protocole d'appel ou mécanisme de transport particulier. Les composants SCA sont décrits à l'aide du langage SCDL (Service Component Definition Language) qui est un langage basé sur XML.

Un composant SCA dispose des caractéristiques suivantes :

WebSphere Integration Developer prend en charge les artefacts d'implémentation suivants pour WebSphere Enterprise Service Bus et WebSphere Process Server :
Tableau 1. Artefacts d'implémentation
WebSphere ESB WebSphere Process Server
Flux de médiation Flux de médiation
Objets Java™ simples Objets Java simples
  Processus métier
  Machines d'état métier
  Règles métier
  Tâches utilisateur

L'architecture SCA distingue la logique métier de l'infrastructure afin que les programmeurs d'application puissent se consacrer à la résolution d'incidents métier. WebSphere Process Server d'IBM se base sur ce même principe. La Figure 1 affiche le modèle architectural de WebSphere Process Server.

Figure 1. Structure à base de composants WebSphere Process Server
Structure à base de composants WebSphere Process Server

Dans l'environnement WebSphere, la structure SCA se base sur l'environnement d'exécution Java 2 Platform, Enterprise Edition (J2EE) de WebSphere Application Server. La structure générale de WebSphere Process Server se compose d'un noyau SOA, de services auxiliaires et de composants de service. La même structure dotée d'un sous-ensemble de cette capacité globale, axée plus spécifiquement sur les besoins de connectivité et d'intégration des applications de l'intégration métier, est disponible dans WebSphere Enterprise Service Bus.

L'interface d'un composant SCA peut être représentée de l'une des manières suivantes :
Un module SCA est un groupe de composants connectés les uns aux autres après avoir directement relié les références et les implémentations. Dans WebSphere Integration Developer, chaque module SCA dispose d'un diagramme d'assemblage qui lui est associé et qui représente l'application métier intégrée contenant des composants SCA et des fils de connexion. L'une des principales missions du développeur d'intégration est de créer le diagramme d'assemblage en connectant les composants qui forment la solution. WebSphere Integration Developer fournit un éditeur d'assemblage graphique pour vous aider dans cette tâche. Lors de la création d'un diagramme d'assemblage, le développeur d'intégration dispose de deux moyens d'action : L'approche ascendante est plus couramment utilisée lorsque les clients disposent de services existants qu'ils veulent réutiliser et combiner. Lorsque vous souhaitez créer de nouveaux objets métier, vous utiliserez certainement l'approche descendante.

Modèle de programmation SCA : Principes

Le concept d'un composant logiciel est à la base du modèle de programmation SCA. Comme nous l'avons mentionné précédemment, un composant est une unité qui implémente une logique et qui la rend disponible aux autres composants via une interface. Un composant peut également exiger les services rendus disponibles par les autres composants. Dans ce cas, le composant affiche une référence pour ces services.

Dans SCA, chaque composant doit afficher au moins une interface. Le diagramme d'assemblage de la Figure 2 dispose de trois composants : C1, C2 et C3. Chacun d'entre eux dispose d'une interface représentée par la lettre I entourée d'un cercle. Un composant peut également se référer à d'autres composants. Les références sont représentées par la lettre R entourée d'un carré. Les références et les interfaces sont ensuite liées dans un diagramme d'assemblage. En règle générale, le développeur d'intégration "résout" les références en les connectant aux interfaces de composants qui implémentent la logique requise.

Figure 2. Diagramme d'assemblage
Diagramme d'assemblage

Appel de composants SCA

Pour fournir un accès aux services à appeler, le modèle de programmation SCA contient une classe ServiceManager qui permet aux développeurs de rechercher les services disponibles par nom. Voici un fragment de code Java type illustrant la recherche d'un service. La classe ServiceManager permet d'obtenir une référence au service BOFactory qui est un service fourni par le système :

//Get service manager singleton
ServiceManager smgr = new ServiceManager();
//Access BOFactory service
BOFactory bof =(BOFactory)
        smgr.locateService("com/ibm/websphere/bo/BOFactory");
Remarque : Le package de la classe ServiceManager est com.ibm.websphere.sca.

Les développeurs peuvent utiliser un mécanisme similaire pour obtenir les références de leurs propres services en spécifiant le nom du service référence dans la méthode locateService. Après avoir obtenu la référence d'un service à l'aide de la classe ServiceManager, vous pouvez invoquer n'importe quelle opération disponible sur ce service indépendamment du protocole d'appel et du type d'implémentation.

Pour appeler des composants SCA, il existe trois styles d'appel différents :
  • Appel synchrone : Lorsque vous utilisez ce style d'appel, l'appelant attend de façon synchrone que la réponse soit envoyée. Il s'agit du mécanisme d'appel classique.
  • Appel asynchrone : Ce mécanisme permet à l'appelant d'appeler un service sans attendre l'envoi immédiat d'une réponse. Au lieu d'obtenir une réponse, l'appelant obtient un "ticket" qui peut être utilisé ultérieurement pour récupérer la réponse. L'appelant récupère la réponse en appelant une opération spéciale qui doit être fournie par l'appelé dans ce cas de figure.
  • Appel asynchrone avec rappel : Ce style d'appel est identique au précédent, mais l'appelé est chargé de l'envoi de la réponse. L'appelant doit afficher une opération spéciale (opération de rappel) que l'appelé peut appeler lorsque la réponse est prête.

Importations

Parfois, les composants ou les fonctions disponibles sur des systèmes externes indiquent la logique métier, comme les applications existantes ou d'autres implémentations externes. Dans ce cas, le développeur d'intégration ne peut pas résoudre la référence en connectant une référence à un composant qui contient l'implémentation dont il/elle a besoin pour connecter la référence à un composant qui "pointe vers" l'implémentation externe. Ce composant est appelé importation. Lors de la définition d'une importation, vous devez spécifier la méthode d'accès à un service externe (emplacement), ainsi que le protocole d'appel.

Exportations

De même, si l'accès à votre composant s'effectue via des applications externes, ce qui est souvent le cas, vous devez le rendre accessible. Pour cela, utilisez un composant spécial qui affiche votre logique au "monde externe". Ce composant est appelé exportation. Il peut être appelé de façon synchrone ou asynchrone.

Références autonomes

Dans WebSphere ESB, un module de service SCA est intégré comme fichier EAR J2EE qui contient plusieurs autres sous-modules J2EE. Les éléments J2EE, comme un fichier WAR, peuvent être intégrés au module SCA. Les artefacts autres que SCA, comme les JSP, peuvent également être intégrés à un module de service SCA. Ce dernier leur permet d'appeler des services SCA à l'aide du modèle de programmation client SCA grâce à un type de composant spécial appelé "référence autonome".

Le modèle de programmation SCA est hautement déclaratif. Les développeurs d'intégration peuvent configurer des aspects, comme le comportement transactionnel des appels, la propagation des données d'identification de sécurité, si un appel doit être synchrone ou asynchrone de façon déclarative, directement dans le diagramme d'assemblage. L'exécution SCA, non pas les développeurs, doit se charger de l'implémentation du comportement spécifié dans ces modificateurs. La flexibilité déclarative de SCA est l'une des fonctions les plus puissantes de ce modèle de programmation. Les développeurs peuvent se consacrer à implémenter la logique métier, au lieu de répondre aux aspects techniques, comme faciliter les mécanismes d'appel asynchrone. Tous ces aspects sont automatiquement gérés par l'exécution SCA.

Qualificateurs

Les qualificateurs régissent l'interaction entre un client de service et un service cible. Des qualificateurs peuvent être spécifiés dans les références de composant de service, les interfaces et les implémentations. Ils sont généralement externes à une implémentation.

Les différentes catégories de qualificateurs sont les suivantes :

SCA autorise l'application de ces qualificateurs de qualité de service (QoS - Quality of Service) aux composants de façon déclarative (sans aucune programmation ou modification du code d'implémentation des services). Ceci peut être effectué dans WebSphere Integration Developer. En général, les qualificateurs QoS sont appliqués lorsque vous êtes prêt à envisager le déploiement d'une solution. Pour plus d'informations, reportez-vous à la section Référence du qualificateur pour la qualité de service.


concept Rubrique concept

Conditions d'utilisation | Commentaires en retour


Icône d'horodatage Dernière mise à jour: 07 juillet 2010


http://publib.boulder.ibm.com/infocenter/dmndhelp/v6r2mx/topic//com.ibm.websphere.wesb620.doc/doc/cdev_pgsca.html
Copyright IBM Corporation 2005, 2010. All Rights Reserved.
Ce centre d'information est mis en service par la technologie Eclipse (http://www.eclipse.org).