5 Corba

CORBA
■ Présentation - L'OMG
■ Le langage IDL
■ Le mode "statique"
■ Le mode "dynamique"
■ Architecture
■ Exemple
Page 1
1
Motivations
■ Motivations
• influence du concept d’objet
• langage (programmation)
• système (architecture)
■ But poursuivi
• Permettre à des applications actives sur différentes
machines d’un environnement distribué hétérogène de
coopérer au travers d'objets distribués
Page 2
2
O. M. G.
■ Consortium créé en 1989

• + de 850 membres aujourd'hui
• constructeurs, éditeurs de logiciels et utilisateurs
■ Objectif :
• Emergence de standards pour l'intégration d'applications
distribuées hétérogènes et la réutilisation de composants
logiciels.
Page 3
3
O.M.G.
Concepts clés
■ Interopérabilité de composants (applications)
• par l'intermédiaire d'un mode de coopération unifié è
l'appel à des objets distants
• Gestion de l'hétérogénéité des machines, systèmes et
langages par l'utilisation d'un langage pivot commun è
l'OMG IDL
■ Tirer avantage de la technologie "objet"
• Encapsulation, Polymorphisme, Héritage, Exceptions
• Séparation entre interface et réalisation
• Les clients ne dépendent que de l'interface définie
pour les objets qu'ils accèdent.
Page 4
4
O.M.G. - Vision globale
■ Common Object Request Broker Architecture
■ Un Bus à objets distribués = ORB

• transport des requêtes, Activation des Objets, etc.
■ Des services de base (Corba Services)

■ Des utilitaires (Corba Facilities)
■ Des interfaces de domaines (Objets métiers)

• "Interopérabilité sémantique"
Page 5
5
O.M.G. - Modèle
■ Modèle orienté Objet Client/Serveur

• Chaque application peut exporter certaines de ces
fonctionnalités (services) sous la forme d'objets Corba.
• L'interaction entre applications est matérialisée par les
invocations à distance des méthodes des objets ainsi
définis.
• La notion Client/Serveur n'intervient que lors de

l'utilisation d'un objet :
• l'application implantant l'objet est le serveur
• l'application utilisant l'objet est le client
• Une application peut-être à la fois cliente et serveur
Page 6
6
O.M.G. - Modèle
Application Application
Cliente Serveur
Bus CORBA Etat

de l'objet
Référence Objet Activation
Requête
de l'Objet CORBA
Code
d'implantation
Interface
de l'objet
Page 7
7
O.M.G. - Modèle
■ Client
• Application invoquant des objets à travers le bus Corba
■ Référence d'objet
• Structure désignant l'objet Corba et contenant
l'information nécessaire pour le localiser sur le bus
■ Requête
• Mécanisme d'invocation d'une opération ou d'accès à un
attribut
■ Bus Corba
• Achemine les requêtes du client vers l'objet en masquant
les problèmes d'hétérogénéité (langages, systèmes,
matériels, etc.)
Page 8
8
O.M.G. - Modèle
■ Objet Corba
• Composant logiciel cible, entité virtuelle gérée par le bus
Corba
■ Activation
• Processus d'association d'un objet d'implantation à un
objet Corba
■ Implantation de l'objet
• Entité codant l'objet Corba à un instant donné et gérant
un état temporaire de l'objet
• Au cours du temps, un objet Corba peut être associé à
différentes implantations
Page 9
9
O.M.G. - Modèle
■ Code d'implantation
• Ensemble des traitements associés à l'implantation des
opérations de l'objet Corba
• Exemple : une classe C++ ou Java, ou un ensemble de
fonctions C
■ Serveur
• Structure d'accueil des objets d'implantation et des
exécutions des opérations (ex: un processus Unix)
Page 10
10
Architecture Globale
Object Management Architecture
■ OMA : Object Management Architecture
• Vision globale de construction d'applications réparties
• Classification des objets intervenants dans l'application
• Services communs : fonctions systèmes accessibles

sous forme d'objets.
• nommage, persistance, transactions, sécurité, etc.
• Utilitaires communs :
Page 11
11
■ Services communs : Corba Services
• Fonctions systèmes accessibles sous forme d'objets.
• Nommage, persistance, transactions, sécurité, etc.
■ Utilitaires communs : Corba Facilities
• Canevas d'objets ("framework") répondant aux besoins
de certains utilisateurs
• IHM, administration, workflow, etc.
■ Interfaces de domaines : Domain Interface
• Objectif : interopérabilité sémantique entre les systèmes
d'informations des entreprises
• Objets métiers spécifiques à des secteurs d'activités :
Finance, santé, télécoms
Page 12
12
Objets Interfaces Utilitaires communs
applicatifs de domaine
Workflow Administration
Télécoms
Spécifiques Santé Finance DataWare IHM
Bus d’objets répartis
Nommage Vendeur Sécurité Relations Collections Temps Licences Externalisation
Cycle
Interrogations de vie Transactions Propriétés Persistance Events Changements Concurrence
Services objet communs
Page 13
13
Le bus d'objets répartis
Architecture
■ Liaison avec les langages de programmation
• C, C++, SmallTalk, Ada, Cobol et Java.
■ Transparence des invocations
■ Invocation statique et dynamique
• statique : invocations controlées à la compilation
• dynamique : invocations construites et controlées à
l'exécution
■ Activation automatique et transparente des
objets
■ Interopérabilité entre bus
• GIOP (Global Inter-Orb Protocol) è IIOP (Internet IOP) au
dessus de TCP/IP
Page 14
14
Architecture
Serveur
Client
DSI SSI
ORB
SII SII
Interface Object Adaptor
Object Request Broker
Référentiel d'interfaces Référentiel d'implantations

IFR ImplR
Interfaces communes à tous les ORB.

Interfaces propres à chaque type d'objets (stubs et skeltons).
Interface propres à chaque ORB.
Page 15
15
Architecture
■ ORB : Object Request Broker (négociateur)
• Noyau de transport des requêtes (protocoles GIOP, IIOP)
• L'interface du bus fournit les primitives de base :
initialisation, etc.
■ SII : Static Invocation Interface
• Stubs permettant d'effectuer les requêtes statiques
• Générés à partir des définitions OMG-IDL
■ DII : Dynamic Invocation Interface
• Interface permettant la construction dynamique d'une
requête vers un objet Corba sans générer/utiliser
d'interface SII (stub)
Page 16
16
Architecture
■ IFR : Interface Repository
• référentiel des interfaces OMG-IDL accessibles par les
applications
■ SSI : Static Skeleton Interface
• Proxy permettant à l'implantation des objets de recevoir
les requêtes qui leur sont destinées
• Générés à partir des définitions OMG-IDL
■ DSI : Dynamic Skeleton Interface
• Interface permettant d'intercepter dynamiquement une
requête sans générer une interface SSI (proxy)
• Correspond au DII mais coté serveur
Page 17
17
Architecture
■ OA : Object Adaptor
• Création des objets Corba
• Maintient des associations entre objets Corba et
implantations
• Activation des implantations
■ ImplR : Implémentation Repository
• Référentiel des implantations
• Contient l'information nécessaire à l'activation
Page 18
18
Le langage OMG-IDL
■ Langage pivot entre les applications Corba
■ Masque l'hétérogénéïté
■ Description des interfaces d'objets Corba
■ Production du code de communication entre
les objets
■ Description des interfaces du bus Corba
Page 19
19
Le langage OMG-IDL
■ Interopérabilité entre langage généralement

limité à une passerelle vers le langage C
■ Chaque langage définit sa propre vision

• de la structuration des données
• structure, type abstrait, objet, etc.
• de la structuration du code
• fonction, package, classe, etc.
• des mécanismes d'exécution
• allocation mémoire, instanciation d'une classe, etc.
• appel de fonction, invocation de méthode, etc.
Page 20
20
Le langage OMG-IDL
"Esperanto"
■ Une application = des objets Corba
• décrits par des interfaces OMG-IDL
• communiquants via le bus Corba
Code
Code ADA Code
C OMG-IDL Cobol
OMG-IDL OMG-IDL
Application
OMG-IDL OMG-IDL
Objet Objet
C++ Java
Page 21
21
Le langage OMG-IDL
Isolation Interface/Implantation
Interface
Application OMG-IDL
Cliente
Implantation
Objet Serveur
Stub Skeleton
Bus Corba
Page 22
22
Le langage OMG-IDL
■ Définition de l'interface de l'objet en OMG-IDL
• Opérations, paramètres, exceptions
è API de l'objet indépendante des langages
è Les objets peuvent

è être écrits en C, C++, Java, Ada, Cobol, etc.
è Encapsuler des applications "propriétaires"
è Les clients peuvent

è être écrits à la main, générés par des outils
è être écrits en C, C++, etc.
Page 23
23
Le langage OMG-IDL
Coté Client Coté Implantation
Cobol Cobol
C C
IDL IDL
IDL IDL
Ada IDL IDL
Ada
ORB ORB
IDL IDL
Java IDL IDL
Java
IDL IDL
C++ C++
Smalltalk Smalltalk
Page 24
24
CORBA
■ Object Request Broker (ORB):

• Mécanismes permettant aux objets de réaliser des appels
de méthodes sur des objets "distants" de manière
transparente.
• Transparence:
• Distribution
• Localisation
• Hétérogénéïté hardware et software
• Fournit l'interopérabilité entre des applications dans un
environnement distribué hétérogène.
• Permet l'interaction des systèmes d'objets.
Page 25
25
Utilisation de l'OMG-IDL
■ Mode "statique"
• projection des description OMG-IDL vers les langages
d'implantation des clients et des serveurs
■ Mode "dynamique"
• Instanciation sous forme d'objets Corba des descriptions
OMG-IDL conservées dans un référentiel commun
Page 26
26
Mode statique
■ Clients et serveurs utilisent les stubs générés
statiquement.
• Les stubs encapsulent l'utilisation du bus, l'activation, la
distribution des composants et l'hétérogénéité.
Page 27
27
Mode dynamique
■ Motivations
• effectuer une requête sur un service dont l'identité et/ou
la structure n'est pas connue à la compilation du
programme client (statiquement)
■ Principe de réalisation
• construction dynamique d'un appel de méthode
• recherche d'un objet fournissant le service désiré
• recherche des caractéristiques du service (nom de
méthode, nombre et type des paramètres, etc.)
• construction par programme d'une requête (en
utilisant des primitives ad hoc)
Page 28
28
Interface OMG-IDL
■ Abstraction d'un type d'objet Corba

■ API à rendre publique
■ Contient les opérations

• Exportées par l'objet
• utilisées par les autres objets
• Pas (forcément) toutes les méthodes de l'objet
Page 29
29
Opération OMG-IDL
■ Abstraction d'un traitement effectué sur

l'objet
■ Décrit par une signature

• Nom de l'opération
• Paramètres
• Nom formel
• Type
• Mode de passage : in, out, inout (passage par copie)
• Type du résultat
• Cas d'erreurs ou d'exceptions
Page 30
30
Type de données OMG-IDL
■ Objets hétérogènes
• langages de programmation différents
• machines et systèmes différents
è Définition précise (nature et format binaire) des types de

données échangées lors des invocations entre objets
è Gestion automatique de l'hétérogénéïté
■ Le langage OMG-IDL permet la description

précise des types de données et définit
exactement leur format binaire
Page 31
31
Le langage OMG-IDL
■ Langage de spécification fortement typé

• Pas un langage de programmation
■ Un "Esperanto" entre les langages
• indépendants des langages et des compilateurs
• projection vers de nombreux langages
■ Ni Union, ni intersection des langages

• Pas de généricité (template en C++)
• Pas de surcharge, ni de redéfinition d'opérations
• Exceptions (inexistantes en C)
• Passage de paramètre Out (inexistant en Java)
Page 32
32
Le langage OMG-IDL
Exemple
// Interface OMG-IDL d'un service d'annuaire
#include <date.idl> // Réutilisation du service de dates
module annuaire {
typedef String Nom; // Nom d'une personne
typedef sequence<Nom> DesNoms; // Ensemble de noms
struct Personne { // Description d'une personne
Nom nom; // - son nom
string informations; // - données diverses
string telephone; // - son téléphone
string email; // - son @ email
string url; // - son @ www
::date::Date date_naissance;// - sa date de naissance
}
typedef sequence<Personne> DesPersonnes;
Page 33
33
Le langage OMG-IDL
Exemple
interface Repertoire {
readonly attribute string libelle;
exception ExisteDeja { Nom nom; };

exception Inconnu { Nom nom; };
void AjouterPersonne(in Personne personne)

raises(ExisteDeja);
void retirerPersonne(in Nom nom) raises(Inconnu);
void modifierPersonne(in Personne personne)
raises(Inconnu);
Personne obtenirPersonne(in Nom nom) raises(Inconnu);
DesNoms lister();
};
};
Page 34
34
Le langage OMG-IDL
Type de données élémentaires
void rien
short entier 16 bits
unsigned short entier 16 bits non signé
long entier 32 bits
unsigned long entier 32 bits non signé
long long entier 64 bits
…
float, double, long double réel 32, 64 et 128 bits (IEEE)
boolean booleen (true, false)
octet donnée 8 bits (opaque)
char caractère 8 bits (ISO Latin)
wchar caractère 16 bits International
string, wstring chaînes de caractères
string<80>, wstring<256> chaînes de caractères bornées
Page 35
35
Le langage OMG-IDL
Types construits
■ Définition de nouveaux types à partir des
types élémentaires
• Alias
• Equivalence de deux types
typedef unsigned short Jour;
typedef short Annee;
• Enumérations
• Définition d'un type discret (ensemble de valeurs)
enum Mois { jan, fev, mar, … , nov, dec};
Page 36
36
Le langage OMG-IDL
Types construits
• Structure
• Ensemble de champs typés
struct Date {
Jour jour;
Mois mois;
Annee annee;
};
• Unions
• Un discriminant scalaire + un ensemble de choix
union DateMultiFormat {
switch(unsigned short) {
case 0: string chaine;
default: Date date;
};
};
Page 37
37
Le langage OMG-IDL
Types construits
• Tableaux
• Définition d'un ensemble de données homogènes
• Taille définie à la spécification, multiple dimensions
typedef long[10] Vecteur10;
typedef double[10][10] Matrice10x10;
• Séquences
• Définition d'un ensemble de données homogènes
• Taille indéfinie à la spécification, une ! Dimension
typedef sequence<long> Vecteur;
typedef sequence<Vecteur> Matrice;
• Exceptions
• 0 ou n champs typés, similaire aux structures
exception ErreurInterne {};
exception Inconnu { Nom nom; };
Page 38
38
Le langage OMG-IDL
Interface d'objets
■ Définition d'un type d'objets abstrait
• Signature des opérations et attributs
• Espace de définition de types
• Exemple :
interface Repertoire { … };
• Une seule spécification pour de multiples implantations !

• Fonction du contexte
• Fonction de la qualité de service désirée
• Fonction de l'existant
Page 39
39
Le langage OMG-IDL
Opérations
■ Définition d'une opération
• Traitement propre à un type d'objet
• Une signature fortement typée
• arguments, résultat, exceptions
• Mode de passage des paramètres
• in, out, inout
• Passage uniquement par copie !
• Exemple :
Personne obtenirPersonne(in Nom nom)
raises(Inconnu);
Page 40
40
Le langage OMG-IDL
Opérations
■ Les exceptions
• Permet d'avertir l'appelant des erreurs d'exécution lors
de l'invocation d'une opération
• Exceptions utilisateurs
• Problèmes liés à l'utilisation de l'objet
• Explicitement spécifiée dans la signature de
l'opération
• Exception système
• problèmes liés à l'utilisation du bus
• implicitement spécifiée pour toutes les opérations
Page 41
41
Le langage OMG-IDL
Opérations
■ Mode d'appel
• Synchrone (par défaut)
• envoi d'une requête vers l'objet
• attente bloquante d'une réponse
• Asynchrone
oneway void envoyer(Message msg);
• Pas de résultats, de out ou inout
• Implantation souvent fiabilisée
Page 42
42
Le langage OMG-IDL
Attributs
■ Attribut = opération(s) liée à une propriété
interface Exemple {
attribute long prop1;
readonly attribute long prop2;
};
• équivalent à la définition d'une paire d'opération, une
pour accéder la valeur, une pour modifier cette valeur
interface Exemple {
long get_prop1();
void set_prop1(in long val);
void long get_prop2();
};
Page 43
43
Le langage OMG-IDL
Héritage d'interfaces
■ Spécialisation de types d'objets Corba::Object
• Héritage multiple
• Ni surcharge, ni redéfinition Peripherique
■ Exemple
interface Peripherique { … };
Ecran HP
interface Ecran : Peripherique { … };
Interface HP : Peripherique { … };
Interface EcranAvecHP : Ecran, HP { … }; EcranAvecHP
■ Attention : Héritage de spécification

• Héritage d'implantation dépendant du langage
Page 44
44
Le langage OMG-IDL
Modules
■ Regroupement de définitions OMG-IDL
• Espace de nommage
• Eviter les conflits de noms
• Modularité, visibilité et portée des définitions
■ Exemple
module date {
struct Date { … };
}
module Application {
interface Service {
date::Date getDate();
};
};
Page 45
45
Le langage OMG-IDL
Valeurs
■ Par défaut les objets Corba sont passés par
référence
■ Valeur OMG-IDL = structure IDL + opérations

• Copie à l'émission, création à la réception
• prise en compte des graphes d'objets
• héritage simple d'un type valeur

• héritage multiple d'interface
■ Disponible en Corba 3.0
Page 46
46
Le langage OMG-IDL
Méta-données
■ Typage fort contraignant pour décrire des
interfaces généralistes
■ Solution : types de données génériques
• Corba::TypeCode encapsule un type OMG-IDL
• any encapsule n'importe quelle valeur OMG-IDL
■ Exemple
interface Pile {
void empiler(in any valeur);
any depiler();
boolean estVide();
readonly attribute Corba::TypeCode typeValeur;
}
Page 47
47
La compilation OMG-IDL
Projection
C++
Compilateur
IDL/C++
OMG-IDL Compilateur Projection

IDL/Java Java
Compilateur
IDL/IR
Référentiel
des Interfaces
Page 48
48
Notion de projection
■ Traduction des concepts Corba et OMG-IDL

vers les constructions d'un langage de
programmation donné
• Toutes les constructions OMG-IDL
• La notion de référence d'objets Corba
• L'invocation d'opération
• Les modes de passage de paramètres
• La gestion des exceptions
• L'accès aux attributs
• L'API du bus Corba décrite en OMG-IDL
■ Standardisée :
• C, Smalltalk, C++, Ada, Cobol et Java
Page 49
49
Projection OMG-IDL / Java
■ Objectifs :
• Utilisation d'objets Corba depuis un programme Java
• Implanter des objets Java en Corba
■ Portabilité totale
• Langage Java unique
• Sources et bytecodes Java 100% portable
■ Compiler 1 fois, exécuter partout
• Tous les bus Corba Java
Page 50
50
■ Identificateur OMG-IDL = identificateur Java

• Si conflit alors l'identificateur est précédé de '_'
■ Module OMG-IDL = package Java
• Les API du bus sont décrites dans le module OMG-IDL
représenté en Java par le package org.omg.Corba
■ Types élémentaires
OMG-IDL Java OMG-IDL Java
void void unsigned long int

boolean boolean long long long
octet byte unsigned long long long
short short float float
unsigned short short double double
long int long double ?
Page 51
51
■ Types élémentaires
OMG-IDL Java
char char
wchar char
string java.lang.String
wstring java.lang.String
fixed java.math.BigDecimal
■ Types Java "plus large" que types OMG-IDL

• Vérification à l'exécution et générations d'exceptions
Page 52
52
■ Java : pas de passage out et inout

■ Les classes Holder
• Un attribut contenant la valeur
• Un constructeur par défaut
• Un constructeur avec valeur initial
final public class TypeHolder {
public Type value;
public TypeHolder() {}
public TypeHolder(Type v) { value = v; }
}
• Fournies pour les types élémentaires dans le package
org.omg.Corba
• Générées pour tous les types utilisateurs
Page 53
53
■ Les classes Helper

■ Fonctions utiles pour les types OMG-IDL
définis par les utilisateurs
• insertion dans un any
• Extraction depuis un any
• etc.
■ Nom de la classe
• NomTypeOMG-IDL + Helper
• Exemple : DateHelper
Page 54
54
■ Alias
• Pas d'alias en Java è utilisation du type réel
■ Constantes OMG-IDL = constantes Java
■ Structure OMG-IDL = classe Java
• non extensible è final
• chaque champs est représenté par un attribut public
• Un constructeur par défaut et un constructeur initialisant
tous les champs
■ Enumération OMG-IDL è classe Java
• A chaque Label est associé
• Une valeur entière (utile dans les switch)
• Une instance d'objet
Page 55
55
■ Tableaux et séquence OMG-IDL è tableaux

Java
• Contrôle d'accès par Java
• Contrôle à l'emballage par Corba
• Taille différente à la taille déclarée ou supérieure au
maximum
• Exception : Corba::Marshal
Java.lang.Exception
■ Exceptions è classe Java

• Similaire à la projection d'une
structure OMG-IDL Java.lang.RuntimeException
Org.omg.Corba.userException Org.omg.Corba.SystemException
Page 56
56
■ Interface OMG-IDL è interface Java

• Signature des opérations
• Signature des opérations d'accès aux attributs
• une pour l'accès en lecture
• une pour la modification si "non readonly"
• Graphe d'héritage IDL è graphe d'interfaces Java
• Héritage de l'interface org.omg.Corba.Object
• Héritage des interfaces Java respectives
Page 57
57
Exemple
// OMG-IDL
// struct Date { Jour jour; Mois mois; Annee annee };
public final class Date {
public short jour;
public Mois mois;
public short annee;
public Date() {}
public Date(short j, Mois m, short a) {
jour = j;
mois = m;
annee = a;
}
}
Page 58
58
Exemple
// OMG-IDL
// enum Mois { Jan, Fev, … Dec }
public final class Mois {
public static final int _Jan = 0;
public static final Mois Jan = new Mois(_Jan);
…
public static final int _dec = 11;
public static final Mois dimanche = new Mois(_dec);
public int value() { … }

public static Mois from_int(int value) { … }
private Mois(int v) { … }
}
Page 59
59
Exemple
// Utilisation de l'enumeration
Mois m = Mois.Janvier;
switch (m.value()) {
case Mois._Jan: … ;
…
case Mois._Dec: … ;
};
m = Mois.from_int(7);
if (m == Mois.Aout) … ;
Page 60
60
Exemple
// Utilisation de la structure
Date d = new Date();
d.jour = (short) 31;
d.mois = Mois.Dec;
d.annee = (short) 1999;
d = new Date((short) 1, Mois.Jan, (short) 2000);
Page 61
61
Exemple
// OMG-IDL
// interface Exemple {
// long operation( in long p_in,
// out short p_out,
// inout long p_inout);
// }
interface Exemple extends org.omg.Corba.Object {
int operation(int p_in,
org.omg.Corba.ShortHolder p_out,
org.omg.Corba.IntHolder p_inout);
}
Page 62
62
Exemple
// Utilisation des modes de passage
Exemple obj = … ;
ShortHolder p_out = new ShortHolder();

IntHolder p_inout = new IntHolder(131);
int res = obj.operation(57, p_out, p_inout);
short v1 = p_out.value;
int v2 = p_inout.value;
Page 63
63
Orbacus
■ Object Oriented Concepts

• http://www.ooc.com
• gratuit, sources disponibles
■ Environnement Corba2.0
• Projections C++ et Java
• Compilateur générant les souches
• Bibliotèques implantant le bus
• Les mécanismes dynamiques
• référentiel d'interface, DII et DSI.
• Des services : nommage, événements, etc.
• OS: Solaris, Linux, Windows 95/NT, AIX, etc.
Page 64
64
Orbacus
Applications C++ Applications Java

Cliente et/ou Serveur Cliente et/ou Serveur
Stubs/Skeletons Stubs/Skeletons
Classes C++ Classes Java
Bibliothèque Corba Bibliothèque Corba
Classes C++ Classes Java
Sockets TCP/IP Sockets Java
OS JVM
ORB Core sur Internet (IIOP)
Page 65
65
Exemple : Hello en Java
Hello.idl
Compilateur
OMG-IDL / Java
_HelloImplBase.java
StubForHello.java
Hello.java
HelloHelper.java HelloImpl.java
HelloHolder.java
HelloClient.java
HelloServeur.java
Client Serveur
Page 66
66
■ Interface OMG-IDL Hello

<Hello.idl>
interface Hello {
void doHello();
};
■ Interface Java Hello

<Hello.java>
public interface Hello extends org.omg.CORBA.Object {
public void doHello();
}
■ Classes Java HelloHelper, HelloHolder
Page 67
67
■ Classe StubForHello : implantation de la souche

• Sert à envoyer les requêtes
• Utilisé en lieu et place de l'objet Hello dans le client
• Invisible pour le programmeur
■ Classe _HelloImplBase
• Recoit et décode les requêtes
• Doit être hérité par l'implantation
<HelloImpl.java>
public class HelloImpl extends _HelloImplBase {
public HelloImpl() {}
public void doHello() {
System.out.println("Hello world!");
}
}
Page 68
68
Org.omg.CORBA
Object
Org.omg.CORBA Org.omg.CORBA
PortableObjectImpl Hello DynamicImplementation
_HelloImplBase
StubForHello _HelloImpl
Classe abstraite Classe concrète extends

interface implements
Page 69
69
<HelloServeur.java>
public class HelloServeur {
public static void main(String args[]) {
try {
// Initialisation du Bus Corba
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
org.omg.CORBA.BOA boa = orb.BOA_init(args, null);
// Creation de l'objet serveur
HelloImpl hello = new HelloImpl();
// Diffusion de la référence de l'objet
System.out.println("IOR(hello)=" + orb.object_to_string(hello));
// Mise en attente du serveur
boa.impl_is_ready(null);
System.exit(0);
} catch (org.omg.CORBA.SystemException exc) {
exc.printStackTrace();
System.exit(1);
}
}
}
Page 70
70
<HelloClient.java>
public class HelloClient {
public static void main(String args[]) {
try {
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
// Creation de la souche Java referencant l'objet distant
org.omg.CORBA.Object obj = orb.string_to_object(args[0]);
Hello hello = HelloHelper.narrow(obj);
// Invocation de l'objet distant
hello.doHello();
System.exit(0);
} catch (org.omg.CORBA.SystemException exc) {
exc.printStackTrace();
System.exit(1);
}
}
}
Page 71
71
■ Génération des souches et squelettes

# mkdir hello
# jidl Hello.idl --package hello
■ Compilation des sources

# mkdir classes
# javac -d classes *.java hello/*.java
■ Execution
# java HelloServeur
IOR(hello)=IOR:10…09
# java HelloClient IOR:10…09
Hello world!
Page 72
72
Exemple : Hello en C++
Hello.idl
Compilateur
OMG-IDL / C++
Hello_skel.h
Hello.cpp Hello_skel.cpp
Hello.h
HelloImpl.cpp
HelloClient.cpp
HelloServeur.cpp
Client Serveur
Page 73
73
■ Définition de la Classe souche : Hello.h

<Hello.h>
class Hello;
Libération automatique de la mémoire !
typedef Hello* Hello_ptr;
class Hello_var { Hello_ptr ptr; … };
class Hello : virtual public CORBA_Object {

…
public:
virtual void doHello();
static Hello_ptr _narrow(CORBA_Object_ptr);

};
■ Implantation de la classe souche : Hello.cpp

• spécifique à chaque ORB !
Page 74
74
■ Définition de la classe squelette : Hello_skel.h

<Hello_skel.h>
#include <Hello.h>
class Hello_skel : virtual public Hello,

virtual public CORBA_Object_skel {
public:
virtual void hello() = 0;
protected:
Hello_skel();
void dispatcher(…);
}
■ Implantation de la classe squelette : Hello_skel.cpp

• Spécifique à chaque ORB
Page 75
75
■ Implantation de Hello en C++ : HelloImpl.cpp

<HelloImpl.cpp>
// Importation du squelette C++
#include <Hello_skel.h>
// Implantation par heritage

class HelloImpl : Hello_skel {
public:
// Constructeur
HelloImpl() : Hello_skel() {};
void doHello() {
cout << "Hello world!" << endl;
}
}
Page 76
76
<HelloServeur.cpp>
#include <Hello_skel.cpp>
int main(int argc, char* argv[]) {
try {
// Initialisation du bus Corba
CORBA_ORB_var orb = CORBA_ORB_init(argc, argv);
CORBA_BOA_var boa = orb->BOA_init(argc, argv);
// Creation de l'objet serveur
Hello_var hello = new HelloImpl();
// Diffusion de la référence de l'objet
CORBA_String_var helloIOR = orb->object_to_string(hello);
cout << "IOR(hello)=" << helloIOR << endl;
// Mise en attente du serveur
boa->impl_is_ready(CORBA_ImplementationDEF::_nil());
return 0;
} catch(CORBA_SystemException& exc) {
PrintException(exc);
return 1;
}
}
Page 77
77
<HelloClient.Cpp>
#include <Hello.h>
int main(int argc, char* argv[]) {
try {
CORBA_ORB_var orb = CORBA_ORB_init(argc, argv);
// Creation de la souche Java referencant l'objet distant
CORBA_Object_var obj = orb->string_to_object(argv[1]);
assert(!CORBA_is_nil(obj));
Hello_var hello = Hello::_narrow(obj);
// Invocation de l'objet distant
hello->doHello();
return 0;
} catch (CORBA_SystemException& exc) {
PrintException(exc);
return 1;
}
}
}
Page 78
78
■ Génération des souches et squelettes
# …/bin/idl Hello.idl
■ Compilation des sources

# gcc <flags> -o Hello.o Hello.cpp
Makefile!
#…
# gcc <flags> -o HelloServeur HelloServeur.o HelloImpl.o
Hello_skel.o Hello.o <bibliothèques>
#…
■ Execution
# ./HelloServeur
IOR(hello)=IOR:10…09
# ./HelloClient IOR:10…09
Hello world!
Page 79
79
Application Serveur
Cliente
Interface
OMG-IDL
Implantation
Objet Serveur
Stub Skeleton
Bus Corba
Page 80
80
class StubForRepertoire
implements Repertoire
extends CorbaStub {
…
}
ExcExisteDeja* ajouter(char* nom, char* tel);
ExcInconnu* supprimer(char* nom);
ExcInconnu* consulter(char* nom, char**tel);
Application Serveur
Interface Repertoire {
Cliente void ajouter(String nom, String tel)
interface Repertoire {
throw(ExisteDeja); void ajouter(String nom, String tel)
Interface nom)
void supprimer(String throw ExisteDeja;
OMG-IDL
throw(Inconnu); void supprimer(String nom)
String consulter(String nom) throw Inconnu;
throw(Inconnu); String consulter(String nom)
} throw Inconnu;
}
Implantation
Objet Serveur
Stub Skeleton
Bus Corba
Page 81
81

5 Corba

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

5 Corba

Transféré par

Droits d'auteur :

Formats disponibles

CORBA

■ Consortium créé en 1989

■ Common Object Request Broker Architecture

■ Un Bus à objets distribués = ORB

■ Des services de base (Corba Services)

■ Des interfaces de domaines (Objets métiers)

■ Modèle orienté Objet Client/Serveur

• La notion Client/Serveur n'intervient que lors de

• Une application peut-être à la fois cliente et serveur

Bus CORBA Etat

• Services communs : fonctions systèmes accessibles

Bus d’objets répartis

Nommage Vendeur Sécurité Relations Collections Temps Licences Externalisation

Services objet communs

Référentiel d'interfaces Référentiel d'implantations

Interfaces communes à tous les ORB.

■ Langage pivot entre les applications Corba

■ Description des interfaces du bus Corba

■ Interopérabilité entre langage généralement

■ Chaque langage définit sa propre vision

è Les objets peuvent

è Les clients peuvent

■ Object Request Broker (ORB):

■ Abstraction d'un type d'objet Corba

■ Contient les opérations

■ Abstraction d'un traitement effectué sur

■ Décrit par une signature

è Définition précise (nature et format binaire) des types de

■ Le langage OMG-IDL permet la description

■ Langage de spécification fortement typé

■ Ni Union, ni intersection des langages

exception ExisteDeja { Nom nom; };

void AjouterPersonne(in Personne personne)

• Une seule spécification pour de multiples implantations !

■ Attention : Héritage de spécification

■ Valeur OMG-IDL = structure IDL + opérations

• héritage simple d'un type valeur

■ Disponible en Corba 3.0

OMG-IDL Compilateur Projection

■ Traduction des concepts Corba et OMG-IDL

■ Identificateur OMG-IDL = identificateur Java

void void unsigned long int

■ Types Java "plus large" que types OMG-IDL

■ Java : pas de passage out et inout

■ Les classes Helper

■ Tableaux et séquence OMG-IDL è tableaux

■ Exceptions è classe Java

■ Interface OMG-IDL è interface Java

public int value() { … }

d = new Date((short) 1, Mois.Jan, (short) 2000);

ShortHolder p_out = new ShortHolder();

int res = obj.operation(57, p_out, p_inout);

■ Object Oriented Concepts

Applications C++ Applications Java

■ Interface OMG-IDL Hello

■ Interface Java Hello

■ Classes Java HelloHelper, HelloHolder

■ Classe StubForHello : implantation de la souche

Classe abstraite Classe concrète extends

■ Génération des souches et squelettes

■ Compilation des sources

■ Définition de la Classe souche : Hello.h

class Hello : virtual public CORBA_Object {

static Hello_ptr _narrow(CORBA_Object_ptr);