UNIVERSITE DE TOULOUSE LE MIRAIL
Département de Mathématiques et Informatique
Equipe G.R.I.M.M.

Introduction à la Norme C.O.R.B.A.
par un exemple de système bancaire

Katia Vinceller
http://www.chez.com/katia/corba
Mai / Juin 1999

Introduction à la Norme C.O.R.B.A. par un exemple de système bancaire

INTRODUCTION

I- CONTEXTE DE TRAVAIL

I.1 Présentation de l'équipe d'accueil et de ses activités

I.2 Présentation du contexte de recherche IHM et Systèmes Distribués

I.3 La programmation orientée objet distribuée

I.3.1 La notion d'objet

I.3.2 JAVA

I.3.3 La norme C.O.R.B.A.

I.3.3.1 L'architecture O.M.A.

I.3.3.2 Le bus CORBA : O.R.B.

Caractéristiques
Distributeur de requêtes objet
Principe d'invocation en mode statique
Architecture

I.3.3.3 Le langage de définition d'interfaces : I.D.L.

Définition
Les constructions du langage I.D.L.
Exemple
Projection vers un langage de programmation

I.3.3.4 Mise en oeuvre d'une application C.O.R.B.A

Ecriture du contrat I.D.L.
Compilation des sources I.D.L.
Projection vers les langages de programmation
Implantation des objets
Ecriture des applications serveurs d'objets
Ecriture des applications clientes, utilisatrices des objets
Installation et configuration des serveurs
Lancement de l'application distribuée

II - STAGE

II.1 Les objectifs
II.2 Les étapes de la conception

II.2.1 Prise en main des outils
II.2.3 Spécification du problème en O.M.T.

II.2.3.1 Définition des objets
II.2.3.2 Modélisation en O.M.T.

II.2.4 Spécification d'un sous-ensemble de classes en l'I.D.L.

II.2.4.1 Spécification des classes, opérations et attributs.
II.2.4.2 Ecriture en I.D.L.

II.2.5 Réalisation d'un sous-ensemble de classes

II.2.5.1 Fichiers généres par le compilateur d'Orbix Web
II.2.5.2 Approche-Implbase ou Approche-TIE ?
II.2.5.3 Classes implantées

II.2.6 Classes et interfaces de test des classes implantées

II.2.6.1 Ecriture du programme serveur : classe ApplServeur
II.2.6.2 Ecriture du programme client et interface d'utilisation

Difficultés posées par la distribution
CONCLUSION
ANNEXES

I.H.M
Trace d'execution
Java doc
Sources

INTRODUCTION

Mon stage de maîtrise s'est déroulé du 26 Avril au 18 Juin à l'Université de Toulouse le Mirail au sein de l'équipe G.R.I.M.M.
Ce rapport porte sur mon travail effectué dans le cadre de la recherche en Interface Homme Machine et Systèmes Distribués.

Durant ces huit semaines, j'ai contribué à la réalisation d'un système bancaire distribué.
La norme C.O.R.B.A. et le langage de programmation Java ont été choisis de la conception à la réalisation.
Les outils logiciels utilisés sont Orbix Web de IONA Technologies, et MS J++.
Ce travail s'est découpé en deux phases de réflexion :

compréhension de la norme C.O.R.B.A. et de son utilisation dans la conception de systèmes distribués.
développement de l'application distribuée de la banque.

REMERCIEMENTS

Mes remerciements se tournent vers mes enseignants et responsables de stage : Mr Jean-Christophe SAKDAVONG, Mme Françoise ADREIT et Mme Sophie EBERSOLD sans qui je n'aurai pu réaliser mon application C.O.R.B.A.

Je tiens également à remercier toutes les personnes avec lesquelles j'ai travaillé et sympathisé : Mme Marie-Pierre CROS, Daniel et Laurent, Fabrice, Isaac et ceux que je ai oublié de citer.

Une attention particulière à toutes les personnes et sociétés que j'ai "visitées" sur Internet et qui m'ont apportés une aide précieuse sur Java et Corba.

Enfin, je ne pourais oublier le soutien et les conseils de Philippe qui a suivi tout mon travail =-)

I- CONTEXTE DE TRAVAIL

I.1. Présentation de l'équipe d'accueil et de ses activités

L'équipe G.R.I.M.M. (Groupe de Recherche en Informatique et Mathématiques du Mirail) est localisée au Département de Mathématiques-Informatique de l'Université du Mirail.
M^r Jean-Marc COUVEIGNES dirige cette unité de recherche qui regroupe enseignants et chercheurs.
Les deux thèmes principaux de recherche sont :

Thème 1 : Algorithmique des courbes et des corps de nombres et applications
(P.CARBONNE, J-M COUVEIGNES, T.HENOCQ).
Deux domaines étudiés :
- L'algorithmique des corps finis et des courbes algébriques sur ces corps ainsi que ses applications au codage et à la cryptographie.
- La géométrie effective des courbes sur les corps globaux.
Thème 2 : Hyperdocuments I.H.M. et systèmes distribués.
Deux domaines étudiés
- Hyperdocuments vs Interaction Homme-Machine : Concepts, Méthodes et Outils
  (Françoise ADREIT, Catherine COMPAROT-POUSSIER).
- La représentation spatio-temporelle d'un système distribué
  (Françoise ADREIT, Sophie EBERSOLD-MARCAILLOU, Jean-Christophe SAKDAVONG)

I.2 Présentation du contexte de travail

Avec le développement et l'utilisation de plus en plus importante d'outils de construction de systèmes distribués (tels que ceux basés sur le standard C.O.R.B.A.), les entreprises sont confrontées au problème de la "conception" de systèmes informatiques distribués.
Ces systèmes sont caractérisés par une distribution dynamique de l'activité et des ressources logicielles sur des sites interconnectés.
Une des principales difficultés est l'appréhension des problèmes liés à l'espace et au temps qui contribuent à une complexification du processus de conception des systèmes informatiques. Il devient ainsi nécessaire de traiter de nouvelles difficultés liées :

au partage, à la duplication, à la mobilité de l'information et des programmes,
au routage de l'information,
à la cohérence des informations,
à la relation entre le temps local à un site et le temps global au système,
à l'évolution dans le temps de la distrtibution
...

Ainsi, l'équipe de recherche s'est intéressée de près à la phase de compréhension du problème, en amont du processus de conception.
Dans le contexte d'un système distribué, une représentation spatiale (représentation des différents sites, des interconnexions, de la répartition des ressources, ...) et temporelle (exécutions parallèles, exécution distribuée, évolution, ...) d'un système distribué constitue un support important dans le processus de compréhension de la situation .
C'est dans cette perspective que l'équipe s'est intéressée :

à l'apport des interfaces homme-machine en conception et utilisation des systèmes distibués,
à l'apport de la notion de point de vue dans la compréhension et le découpage des composants d'un système distribué.

Parallèlement à cette réflexion de fond, l'équipe mène une activité d'expérimentation, basée sur le standard C.O.R.B.A. avec l'outil O.R.B.I.X. Web dédié au langage Java.
L'objectif est de construire un noyau d'expérimentation. Celui-ci sera composé d'un evironnement de conception d'applications distribuées intégrant une interface homme-machine qui permettra une bonne appréhension de l'espace et du temps.
A partir de ce noyau, il sera possible d'envisager des collaborations industrielles (avec la société Delta Partners notamment).

I.3 La programmation orientée objet distribuée

Dernièrement, les systèmes informatiques ont évolué en s'interconnectant (Internet, Intranet, ...).
Ainsi les architectures matérielles et logicielles ont du être modifiées.
Deux approches ont vu le jour :

Ordinateurs client / serveur dans un contexte centralisé . Toute la charge était "déplacée" sur un seul et même serveur => approche inéquitable.
Rôle de client ou serveur défini statiquement.
la deuxième est plus "répartie" car décentralisée : un "organe" peut être soit acteur (serveur), soit consommateur (client) de ressources.
Approche dynamique ou multiple.

De même, des nouveaux mécanismes nécessaires à la distribution ont été mis en place :

Librairies UNIX SystemV (sockets, signaux, sémaphores, mémoire partagée ...)
SUN RPC (Remote Procedure Call / appel de procédures à distance)
SUN a modélisé une version plus moderne adaptée au langage objet Java : R.M.I. (Remote Method Invocation / Invocation de méthodes à distance),
l'O.M.G. (Object Management Goup) a défini C.O.R.B.A. (Common Object Request Broker Architecture / architecture standard pour les objets distribués)

Les différentes approches de programmation qui existaient jusqu'alors étaient :

la programmation impérative (dérivés AGOL 60, Basic, Pascal, C ...),
la programmation fonctionelle (LISP),
la programmation orientée objet (Java, C++, Eiffel, Smalltalk ...) .
...

Or il s'est avéré que la Programmation Orientéé Objet de par sa modularité, était le langage de prédilection des concepteurs d'applications distribuées.
L'apport de l'objet à la distribution vous est expliqué dans ce document.

I.3.1 La notion d'objet

Un objet est une structure qui associe les données aux fonctions (appelées méthodes) qui les exploitent.
Cette structure est composée :

d'une partie publique qui contient ce qui est accessible à l'utilisateur de l'objet; soit :
- son identifiant qui permet le référencement,
- son interface de programmation : signatures des méthodes.
d'une partie privée qui encapsule :
- l'état de l'objet,
- et l'implantation des méthodes de l'interface.

La séparation partie publique / partie privée d'un objet permet aux clients de ne pas se soucier du code d'implantation de l'objet.
D'un autre côté, cela laisse la possibilité aux programmeurs de modifier la partie interne de l'objet sans incommoder les utilisateurs.
Les objets de même nature sont crées sur la base d'un modèle commun : la classe de l'objet.
Une relation de hiérarchie peut être établie entre les classes pour factoriser leurs caractéristiques communes.
On parle alors :

d'héritage simple lorsqu'une classe hérite d'une seule classe,
et d'héritage multiple si une classe hérite de plusieurs autres classes.

Illustrons l'héritage par un exemple concret :
Tous les oiseaux (classe mère : Oiseau) volent (methode voler()) et sont ovipares.
Un canard est un oiseau (la classe Canard hérite de Oiseau) .
Le canard vole (selon la méthode voler() définie dans le modèle) et il nage (méthode supplémentaire spécifique au Canard).
Soit maintenant un pingouin (classe Pingouin).
Un pingouin est un oiseau (Pingouin hérite de Oiseau) ovipare mais qui ne vole pas comme un oiseau.
on redéfinit alors la méthode voler() pour le Pingouin.
On parle alors de polymorphisme.

Tous les mécanismes d'encapsulation, d'héritage et de polymorphisme font de la P.O.O. une approche modulable et extensible.
L'approche orientée objet se prête donc bien à la construction d'applications complexes notamment dans un contexte distibué.

I.3.2 JAVA

Le langage Java est un langage objet à part entière.
Ce langage objet est basé sur C++ en ayant exclu la plupart de ses défauts.
Outre les aspects de programmation, son principal avantage est d'être 100% portable :
source compilée une fois, exécutable partout.
Cela vient du fait que le langage Java est interprété par une machine virtuelle définie selon une norme bien précise.
Une machine virtuelle n'est ni plus ni moins qu'un interpréteur qui execute le byte-code compilé java sur un systeme d'exploitation et donc pour un ordinateur.
Le langage Java a été élaboré par une entreprise commerciale SUN mais dans un contexte trés ouvert . Ainsi on dispose d'une riche A.P.I. et de nombreuses documentations.

Ce langage étant relativement récent, toutes les technologies actuelles ont y été implantées : support internet, web (java.net), multimédia (java.awt, java.3d) , base de données (jdbc) et commerce électronique (java.wallet) ...

Depuis la distribution java 1.2 le jdk (compilateur et environnement de programmation) inclu pleinement C.O.R.B.A. avec son O.R.B. et compilateur d'IDL.

I.3.3 La norme C.O.R.B.A.

(Common Object Request Broker Architecture / architecture standard pour les objets distribués)

C.O.R.B.A. a été développé par l'O.M.G. (Object Management Group).
L'O.M.G. est un consortium international regroupant des fournisseurs de matériels (SUN, HP, IBM, ...), des fournisseurs de logiciels (I.O.N.A., Borland, Oracle, Microsoft, ...) et des grands utilisateurs comme Motorola, Alcatel, Boeing.
Son but est de définir des standards pour l'intégration d'applications distribuées hétérogènes.
Pour que ces applications répondent aux besoins de communication, de portabilité et d'interopérabilité, l'O.M.G. a défini un modèle de référence : la norme C.O.R.B.A .
C.O.R.B.A. utilise:

les technologies orientées objet :
- l'architecture O.M.A. (Object Management Architecture) de gestion des objets,
- un bus d'objets répartis C.O.R.B.A . : l'O.R.B. (Object Request Broken / distributeur de requêtes objet), qui facilite la communication entre objets distribués hétérogènes,
- un langage de description d'interfaces: l'O.M.G. - I.D.L. (Interface Definition Language / langage de définition d'interfaces), qui assure l'interopérabilité entre les objets implantés,
- des services objet et des utilitaires communs qui fournissent une large gamme de composants logiciels destinés à la construction d'applications distribuées.
les mécanismes de l'approche orientée objet :
- encapsulation,
- polymorphisme,
- héritage.

Ainsi, les objets C.O.R.B.A. peuvent être localisés n'importe où sur un réseau (internet par exemple), ils peuvent aussi interargir avec d'autres objets situés sur d'autres sites. Ils sont écrits dans n'importe quel langage de programmation pour lequel l'association avec l'I.D.L. existe.

Architecture CORBA

I.3.3.1 L'architecture O.M.A.

(Object Management Architecture)

Cette architecture globale de l'O.M.A. propose une classisfication des types d'objets C.O.R.B.A. selon leur fonctionnalité dans les applications distribuées.
Elle structure ces fonctionnalités en quatre catégories de composantes :

Les services objet communs sont des objets C.O.R.B.A. spécifiés par des interfaces I.D.L.
Ils offrent des services système de bas niveau communs à la majorité des applications distribuées (nommage, persistance, sécurité et transaction entre les objets répartis).
Les utilitaires communs apportent des fonctionnalités de plus haut niveau.
Ils offrent des composants logiciels réutilisables (interface utilisateur, gestion de l'information, administration du système et gestion des tâches).
Les interfaces de domaine fournissent les standards ID.L. pour assurer l'interopérabilité entre des objets de métier destinés à des secteurs économiques (Santé, Finance, Télécom)
Les objets applicatifs décrits en I.D.L permettent d'assembler et d'intégrer les composants pré-existants.

Tous ces objets dialoguent à travers le bus d'objets répartis C.O.R.B.A. : l'O.R.B (Object Request Broker / distributeur de requêtes objet) qui fournit l'infrastructure de communication.

I.3.3.2 Le bus C.O.R.B.A. : O.R.B.

(Object Request Broker / distributeur de requêtes objet)

Caractéristiques

A l'image d'un bus matériel, l'O.R.B. est un outil de communication entre différents éléments logiciels répondant à la norme C.O.R.B.A. Il permet de résoudre les besoins d'interopérabilité et d'intégration de technologies informatiques hétérogènes.
Il gère de façon tranparente :

les différences entre les langages d'implantation des objets, les systèmes d'exploitation et les architectures matérielles.
Cela est dû à la séparation entre l'interface et l'implantation des objets offerte par le langage I.D.L.
la localisation des objets sur le réseau, ainsi que leur mécanisme d'invocation (statique ou dynamique)

Pour permettre la communication entre bus différents à travers le monde entier, l'O.M.G. a spécifié le protocole I.I.O.P. (Internet Inter-O.R.B. Protocol / protocole d'interopérabilité entre O.R.B. sur Internet).
I.I.O.P. est l'implantation du potocole G.I.O.P. (General Inter-O.R.B. Protocol) basé sur TCP/IP.

Distributeur de requêtes objet

Comme son nom l'indique, l'O.R.B. assure le transport des requêtes entre les objets distribués.
Il fonctionne selon un modèle objet de type client/serveur.

L'application implantant l'objet est le serveur.
L'appplication utilisant l'objet est le client.

(Néanmoins, une application peut être à la fois cliente et serveur).
Notons : le client ne connaît :

ni la localisation de l'objet,
ni son implantation,
ni quel O.R.B. est utilisé pour accéder à l'objet.

Tout ceci reste transparent à l'utilisateur.
Le client peut seulement invoquer les méthodes spécifiées par l'interface de l'objet C.O.R.B.A.

L'O.R.B est utilisé aussi bien par le client que par le serveur via des souches de communication (appelées aussi talons ou proxy).

Ces souches masquent les communications à travers le reseau.
Elles sont générées automatiquement par le compilateur d'I.D.L. (décrit plus loin) à partir des sources I.D.L.
A chaque objet décrit en I.D.L. sont générées une souche client et une souche serveur.

Du côté client, la souche s'appelle le "stub"; elle est stockée dans l'espace d'adressage du client et représente l'objet distant. C'est à ce représentant que le client adressera ses requêtes.
De façon symétrique, le serveur dispose d'une souche serveur de l'objet : le "skeleton" qui reçoit la requête du client et invoque l'objet.

Principe d'invocation en mode statique

Le client d'un objet C.O.R.B.A. dispose d'une référence de l'objet dans son espace mémoire.
Il utilise celle-ci pour manipuler l'objet.
Le client invoque une méthode spécifique sur la référence de l'objet.
Si l'objet est distant, son stub associé emballe les arguments de la requête et la transmet à l'O.R.B.
Le réseau transporte l'invocation via l'O.R.B.
La souche serveur associée à l'objet déballe les arguments et invoque l'objet.
L'objet transmet le résultat au squelette qui l'emballe.
Le réseau transporte le résultat via l'O.R.B.
Le stub déballe le résultat et le transmet au client.

Architecture

L'O.R.B. transporte les requêtes.
Les interfaces d'invocations statiques.
L'interface d'invocation dynamique.
Le référentiel des interfaces contient toutes les définitions I.D.L. des objets du bus.
L'interface de l'O.R.B. fournit les primitives de base de C.O.R.B.A.
Les interfaces de squelettes statiques.
Les interfaces de squelettes dynamiques.
L'adaptateur d'objets qui exécute les requêtes et active les objets.
Le référentiel des implantations décrit l'implantation des objets.

Particularité :
Il existe deux mécanismes pour invoquer les objets :

l'invocation statique (la plus simple et la plus utilisée) :
le programmeur écrit les invocations sur les objets en utilisant les souches de communication (produites par un précompilateur d'I.D.L). Les invocations sont contrôlées à la compilation.
C'est une approche bien adaptée pour la compilation et l'exécution d'applications ayant des spécifications I.D.L. stabilisées.
l'invocation dynamique :
les requêtes d'invocation sont construites dynamiquement à l'aide du référentiel des interfaces (R.I. Repository Interface). Les invocations sont controlées à l'exécution.
Cette approche convient aux applications dont certaines spécifications évoluent au cours du temps.

I.3.3.3 Le langage de définition d'interfaces : I.D.L.

(Interface Definition Language)

Développer des applications distribuées sur des plate-formes hétérogènes nécessite une séparation stricte interface / implantation.
En effet rappelons que c'est selon l'interface que les applications clientes peuvent manipuler les objets.
Ainsi, pour pouvoir décrire ces interfaces, l'O.M.G. a conçu l'I.D.L.
L'I.D.L. assure aussi la correspondance avec différents langages de programmation.

Définition

L'I.D.L. permet de décrire les interfaces des objets.
C'est un langage déclarartif orienté objet dont la syntaxe est très inspirée du langage C++ ou Java.
L'I.D.L. définit pour un objet distribué :

des opérations,
des attributs,
des types,
et des exceptions.

Une interface peut hériter d'une ou plusieurs interfaces : héritage de spécification multiple.

Les constructions du langage I.D.L.

des types élémentaires de données (void, long, char, string, ...),
des constantes,
des types construits,
des exceptions,
des interfaces (opérations, attributs, ...),
des modules,
des valeurs,
des pragmas,
des types de méta-données.

Exemple :

Interface d'une Banque en I.D.L. :

/*classe de définition d'une banque */
interface Banque { 
	readonly attribute string nombanque;
	long ouvrirCompte(in string nom); 
	void fermerCompte(in long numero); 
	void crediterCompte(in float montant,in long numero ); 
	void debiterCompte(in float montant,in long numero); 
	float soldeCompte(in long numero); 
	string listeClients(); 
};

Projection vers un langage de programmation

Pour pouvoir exploiter les défintions I.D.L., l'environnement C.O.R.B.A. fournit des compilateurs I.D.L. qui dépendent du langage cible et de l'implantation du bus.
Ces précompilateurs transforment ces définitions I.D.L. en des constructions utilisables depuis des langages de programmation.
Précompilateurs existants : I.D.L. vers Java, C, C++, Corba-script, Smalltalk, Cobol, Ada.
Pour chaque interface I.D.L., le précompilateur génère :

une interface dans le langage cible,
un stub client dans l'environnement de programmation du client,
un squelette serveur dans l'environnement de programmation du serveur,
d'autres fichiers dans le langage cible nécesaires à la distribution entre client et serveur.

Reprenons l'exemple ci-dessus.
Avec un précompilateur I.D.L. vers Java , les fichiers suivants sont générés pour l'interface Banque

une interface java (Banque.java),
un stub client en java (_BanqueStub.java),
un squelette serveur en java (_BanqueSkeleton.java),
et d'autres fichiers java (BanqueHelper.java , BanqueHolder.java) nécessaires pour l'ecriture du client et du serveur.

_BanqueStub.java sera utilisé pour développer le programme client.
_BanqueSkeleton.java sera utilisé pour implanter l'objet Banque sur le serveur.

I.3.3.4 Mise en oeuvre d'une application C.O.R.B.A.

En reprenant les concepts décrits dans cette première partie sur C.O.R.B.A., un schéma type de mise en place d'une application distribuée peut être décrit comme suit :

Ecriture du contrat I.D.L.
Dans une approche orientée objet (en O.M.T. par exemple), on définit dans un premier temps les objets de l'application distibuée, puis dans un second temps on modélise les objets sous forme de contrats I.D.L.
Ces contrats en I.D.L. décrivent les interfaces des objets et des types de données.
On les enregistre dans un fichier texte (Banque.idl) .
Compilation des sources I.D.L.
Le compilateur choisi opère un contrôle syntaxique et sémantique des définitions I.D.L contenues dans le fichier texte.
Les définitions sont chargées dans le référentiel des interfaces.
Projection vers les langages de programmation
Le compilateur a généré le code des souches :
- stub, utilisé par les applications clientes
- squelettes, pour les programmes serveurs implantant ces objets.
La projection est spécifique à chaque langage de programmation.
Implantation des objets
L'implantation d'un objet définit le comportement pour les opérations et attributs de son interface.
L'implantation complète ou réutilse le code généré par les squelettes et stubs.
Le développeur implante les objets dans le langage de son choix en respectant les règles de projection vers le langage choisi.
Ecriture des applications serveurs d'objets
Le développeur code les programmes serveurs qui incluent implantation des objets et squelettes pré-générés.
Ces programmes contiennent le code pour :
- se connecter à un O.R.B.,
- instancier les objets sur le serveur,
- rendre publiques les références sur ces objets à l'aide du service nommage,
- se mettre en attente des requêtes des clients pou ces objets.
Ecriture des applications clientes, utilisatrices des objets
Ce sont dans ces programmes que l'on invoque les opérations sur les objets.
Ces programmes incluent :
- le code des souches (méthodes de liaison avec les serveurs, ...),
- les références aux objets utilisés,
- le code pour l'Interface Homme Machine,
- le code spécifique à l'application
Installation et configuration des serveurs
On enregistre les serveurs d'objets auprès du référentiel des implantations. Ceci permet d'automatiser leur activation lorsque les requêtes vont arriver.
Diffusion et configuration des clients
Après avoir écrit les programmes clients, il est nécessaire de diffuser les exécutables sur les sites clients.
Lancement de l'application distribuée
Le bus C.O.R.B.A. : l'O.R.B assure alors les communications entre les clients et les objets disponibles sur tels serveurs via le protocole I.I.O.P.

Premier exemple applicatif réalisé avec Orbix Web 3.0 de IONA

Orbix Web 3.0 de IONA est un logiciel qui permet de développer des applications distribuées C.O.R.B.A.
C'est un outil dédié au langage Java, il intègre un O.R.B., un compilateur d'I.D.L vers Java, et toutes les autres fonctionnalités nécéssaires au dévelopement de systèmes distribués.

Considérons un objet Banque sur lequel nous souhaitons effectuer les opérations élémentaires de gestion de comptes bancaires : ouvrirCompte(nomclient), fermerCompte(numerocompte), crediterCompte(montant, numerocompte), debiterCompte(montant, numerocompte) ...
Nous spécifions l'interface de la banque en I.D.L. (cf plus haut exemple dans le document).
Après avoir écrit ce contrat I.D.L, le compilateur choisi (ici I.D.L vers Java) fait le reste.
Effectivement, de la projection vers le langage Java, sont générés principalement :

l'interface java correspondante (Banque.java),
les souches stub et squelttes (_BanqueStub.java), (_BanqueSkeleton.java),
d'autres fichiers utiles à la programmation distribuée.

Dans un second temps, nous implantons notre objet Banque en java (langage de programmation choisi) :
écriture de la classe BanqueImplementation qui réutilise les squelettes générés par le compilateur d'I.D.L.
BanqueImplementation implante l'interface Banque et hérite de la classe _BanqueSkeleton.

Une fois notre objet banque implanté, nous écrivons un programme serveur en Java :
classe BanqueServeur qui "met" les objets (Banque en l'occurence) à la disposition des clients.
Ecriture du programme serveur

import IE.Iona.OrbixWeb._CORBA;
import IE.Iona.OrbixWeb.CORBA.ORB;
import IE.Iona.OrbixWeb.CORBA.ORB;	

public class BanqueServeur{
     public static void main(String args[]){

          Banque b=null;
          ORB orb;

          // création et initialisation de l'orb
          orb=(ORB)org.omg.CORBA.ORB.init();

          // création de l'objet Banque : b
          b=new BanqueImplementation("Crédit Agricole");

          // enregistrement avec l'orb de la Banque b (de nom "ca" sur le serveur)
          orb.connect(b,"ca");

          // BanqueSr: serveur de la  banque "ca" 
          _CORBA.Orbix.impl_is_ready("BanqueSr");
			
          try { Thread.sleep(500000); }

          catch (InterruptedException ex) {}

          // déconnexion de b de l'orb
          orb.disconnect(b);
          System.out.println("déconnexion");
     }
}

Un objet Banque (b) est maintenant disponible sur le serveur BanqueSr.
Pour que le(s) client(s) puisse(nt) l'utiliser, cet objet doit être identifiable.
Dans ce court exemple, il n'a pas été nécessaire d'employer le service nommage car l'application réalisée est simple.
En effet, un seul et unique objet (Banque b) est enregistré sur le serveur.

Regardons maintenant le programme client qui va utiliser b et c.

Ecriture du programme client

import org.omg.CORBA.ORB;
import IE.Iona.OrbixWeb._CORBA;
import javax.swing.*;

public class BanqueClient {
    public static void main(String args[]){

        //initialisation de l'O.R.B.
        ORB.init();

        //référence x à une Banque
        Banque x=null;

        //référence x à l'objet Banque b du serveur "BanqueSr"
        x=BanqueHelper.bind(":BanqueSr","mass-171315.univ-tlse2.fr");

        JOptionPane.showMessageDialog(null,
                                      "Bienvenue à la banque du " + x.nombanque());
		
        //saisie du nom d'un futur client
        String S = JOptionPane.showInputDialog(null,
                                               "A quel nom souhaitez-vous ouvrir un compte ?");
		
        //ouverture du compte pour S
        int a=x.ouvrirCompte(S);
    };
}

Schéma récapitulatif des classes écrites et générées

Remarque :
Jusqu'à présent, en java, dans un systeme non distribué, une référence désignait un objet lorsque celui ci etait "alloué" par l'opérateur new. La machine virtuelle java (J.V.M.) renvoyait alors l'objet à l'application qui l'utilisait.
Par analogie, dans un systeme distribué corba, les objets sont "renvoyés" du serveur au client par la méthode bind(identificateur_obj, hote_obj) du stub BanqueHelper.

II- STAGE : Un système bancaire distribué

II.1 Les objectifs

Dans le cadre de la recherche sur l'Interface Homme Machine et les Systèmes Distribués, le sujet de mon stage était de construire un noyau d'expérimentation d'un système bancaire distribué, basé sur le standard C.O.R.B.A..
Cette construction avait pour objectif de faire ressortir les difficultés liées à la conception de Systèmes Distribués et tout particulièrement celles spécifiques au rapport espace / temps.
Pour cela, je devais utiliser l'O.R.B. Orbix Web de I.O.N.A dédié au langage Java.
Cependant, mon premier objectif a été de comprendre ce qu'était C.O.R.B.A., et comment utiliser cette norme dans le développement d'applications distribuées.
Ce que j'ai retenu et compris de ce concept vous est expliqué ci-dessus dans la première partie du document.
Par la suite, ce projet a impliqué :

la prise en main d'outils nécessaires au développement de l'application (Microsoft Visual J++, IONA Obix Web, Javasoft Swing),
la connaissance de la norme O.M.T. pour modéliser le système bancaire,
l'utilisation d'un langage particulier : l'I.D.L. pour spécifier les classes,
de bonnes bases en programmation orientée objet pour implanter les classes et l'application,
enfin, de la rigueur et beaucoup de temps pour mener à terme ce "noyau " d'un système bancaire distribué.

Ainsi, je vous expose à travers ce rapport toutes ces étapes du cycle de conception, mais aussi les difficultés posées par la distribution.

II.2 Les étapes de la conception

II.2.1 Prise en main des outils

Orbix Web 3.0 de IONA Technologies

Orbix Web est un environnement logiciel qui permet de construire et d'intégrer des applications distribuées.
Orbix Web est une implantation complète de la spécification C.O.R.B.A. de l'O.M.G.
Il associe la fonctionnalité C.O.R.B.A. au langage de programmation Java.
Orbix combine :

une approche puissante basée sur des standards pour le développement d'applications distribuées,
avec la fléxibilité et la facilité d'utilisation de l'environnement Java.

Orbix web intègre les fonctionnalités suivantes :

un O.R.B programmé en Java,
un serveur java : Java Activator : orbixdj,
un support complet pour l'adaptation I.D.L. / Java.

Par ailleurs, la technologie IONA est conforme au protocole I.I.O.P. assurant ainsi l'interopérablité avec d'autres O.R.B.

Microsoft Visual J++

L'outil de développement choisi est Microsoft Visual J++, c'est non seulement un compilateur java mais aussi un I.D.E. (Integrated Developement Environement) qui comporte :

Un éditeur
Un compilateur
Une documentation (A.P.I.)
Un débugueur
Un éditeur de ressources graphiques
Un explorateur d'objets (liste des objets, classes, méthodes).
...

Cet outil a un avantage notoire la convivialité, mais aussi comme inconvénient sa non fiabilité. En effet le langage J++ n'a pas été attribué 100 % Java compatible.

Javasoft Swing

J'ai également utilisé Swing 1.1.1 Beta (connue officiellement sous "Java Foundation Classes 1.1").
Ce pakage 100% java comporte un ensemble de classes d'objets graphiques, tout comme java.awt swing permet de créer des interfaces mais beaucoup plus ergonomiques et strictement identiques sur des plate-formes différentes.

II.2.3 Spécification du problème en O.M.T.

II.2.3.1 Définition des objets

M^me F ADREIT, M^me S EBERSOLD, M^r JC SAKDAVONG et moi même avons réfléchi sur les objets qui pourraient composer notre futur système bancaire.
Cette phase de réflexion s'est appuyée sur le fonctionnement d'une banque dans le monde réel. Nous nous sommes intéressés plus particulièrement au système bancaire français, et à ses règles de gestion.
Ainsi, nous avons pu faire ressortir les points suivants :

Un organisme compensateur gère les échanges entre toutes les banques.
L'organisme compensateur représente donc un objet important du système bancaire car il "supervise" en quelque sorte tout le système de gestion des banques.
Une banque possède un certain nombre d'agences dispersées à travers le pays. Comme nous l'avons décrit ci-dessus, toute banque dialogue avec l'organisme compensateur.
Une agence d'une banque peut disposer de plusieurs guichets dans sa ville :
- Des guichets humains.
  A l'écoute des requêtes des clients, et ils effectuent toutes les opérations bancaires demandées.
- Des guichets automatiques pour les clients possédant une carte banque dédiée (ou carte propriétaire).
  Ces guichets permettent aux clients d'effectuer des consultations du solde et des opérations réalisées. Les clients peuvent aussi y effectuer des retraits d'argent.
  Les opérations de dépôt et de virement sont impossibles avec ce genre de guichet.
- Des distributeurs automatiques.
  Ce sont des guichets accessibles avec une carte bancaire(carte magnétique comme la carte bleue). On peut y effectuer seulement les opérations de consultation et de retrait d'argent.
  On les appellera par la suite guichet CB. C'est une autre famille de guichets automatiques.
- Des guichets "déplacés" chez les commerçants.
  Lorsque nous allons faire des achats dans les magasins, nous pouvons régler la note avec la carte bancaire.
Un gestionnaire gère tous les comptes enregistrés dans cette agence de la banque en question.

Après avoir dépeind plus ou moins l'environnement bancaire, penchons nous maintenant sur les mécanismes internes de gestion des comptes à travers ce réseau.

chaque agence possède un gestionnaire de comptes, qui comme son nom l'indique s'occupe des transactions bancaires sur chaque compte ouvert dans cette agence.
Il y a deux sortes de comptes bancaires :
- le compte client, ouvert pour un client de l'agence.
  Initialement, le client dispose pour chacun de ses comptes d'une carte bancaire propriétaire.
  Mais un client peut aussi désirer une carte bleue, alors il disposera en plus d'un compte carte bleue.
- le compte carte bleue n'a de sens que si le client posède une carte bancaire, en l'occrurence une carte bleue.
  Ce compte est rattaché à une centre de cartes bleues qui gère les opérations de débit sur ce compte.
un centre carte bleue supervise l'ensemble des guichets utilisables avec la carte bleue.
quant au client , acteur dans ce réseau bancaire, il peut être décrit :
- par son identité : nom, prénom, age : données non modifiables ,
- mais aussi par d'autres caractéristiques variables comme l'adresse par exemple.
  En effet, un même client peut résider dans deux domiciles différents. Pourtant il posséde un seul et même compte mais géré tantôt par la première agence et tantôt par la deuxième.

Maintenant que les objets et leur relation ont été convenus, comment exprimer alors clairement la répartition et les liaisons entre eux?
Une représentation graphique semble être le mieux adapté.
Nous avons donc choisi de modéliser l'application en O.M.T. (Object Model Techniques) selon les recommandations de M EBERSOLD.

II.2.3.2 Modélisation en O.M.T.

Qu'est ce que l'O.M.T.?

La notation graphique obtenue à partir des objets décrits ci-dessus est la suivante :

Notations :

un losange désigne une cardinalité multiple.
Par exemple, on lit : un organisme compensateur a plusieurs banques.
un point noir désigne une cardinalité "unique".
Exemple : une banque a un et un seul organisme compensateur.
un point blanc (vide cerclé de noir) illustre une cardinalité nulle.
le triangle représente la notion d'héritage.
Exemple : guichet CB et guichet Agence héritent de Guichet; (ce sont bien en effet deux sous-classes de guichet).

Cette représentation graphique symbolise parfaitement la structure de l'application.
Il nous reste maintenant à définir les classes et les opérations possibles sur celles-ci.

II.2.4 Spécification d'un sous-ensemble de classes en I.D.L.

Par manque de temps et par souci de "justesse", seules les classes en relation avec le gestionnaire ont été spécifiées.
En effet, le fonctionnement d'une banque peut s'apparenter à celui du gestionnaire de comptes.
En fait, dans une banque, on retrouve toutes les opérations les plus élémentaires, décrites par le gestionnaire.
Ainsi, j'ai concentré mon travail sur la réalisation d'une mini-application (un noyau), simulant le "comportement " d'un guichet client "face" au gestionnaire de comptes d'une banque.
Plusieurs guichets clients pouront alors utiliser les fonctionnalités offertes par le gestionnaire de leur banque. Ceci grâce à la distribution de l'application cliente sur plusieurs sites (ordinateurs, plate-formes hétérogènes).
L'application serveur de gestionnaires sera lancée sur un site, attendant les requêtes des "guichets" clients.
Par ailleurs, j 'ai tenu à spécifier mes classes de la façon la plus générale possible. Ceci afin que mon travail puisse être complété par la suite, en y intégrant le reste des objets décrits dans le modèle O.M.T.ci-dessus.

II.2.4.1 Spécification des classes, opérations et attributs.

C'est une étape fondamentale qu'il ne faut pas abréger car elle évite par la suite de comettre des erreurs de conception, de revenir en arrière et de perdre du temps.
Il est donc important de bien spécifier tous nos objets et les opérations possibles sur ceux-ci avant de se lancer dans la programmation proprement dite.

Les classes retenues

Du schéma des classes ci-dessus, nous nous sommes intéressés aux classes suivantes :

Agence. Elle est identifiable par :
- son nom,
- (la banque à laquelle elle appartient, ici la classe banque n 'a pas été implantée; mais il est facile de voir qu'une banque a un nom, un ensemble d'agences, et est rattachée à l'organisme compensateur).
- le gestionnaire qu'elle acceuille.
Gestionnaire . Il a toutes les fonctionnalités nécessaires à la gestion des comptes bancaires :
- créer un compte client en prenant connaissance :
  - du client,
  - d'un numéro local qui s'incrémente à chaque ouverture de compte,
  - de la somme déposée initialement,
  - du découvert maximum autorisé,
  - et d'un libellé.
  De façon symétrique, nous pouvons reprendre cette méthode pour la création d'un compte CB.
- fermer un compte,
- migrer un compte vers une autre agence,
- enregistrer tous les comptes ouverts dans une table [identite bancaire <=> compte],
- accéder à un compte pour un identite bancaire donnée, et inversement,
- obtenir l'agence auquel il appartient, le numéro guichet correspondant et le libelle qui le caractérise.
Compte. Un compte est caractérisé par son client, un libellé, un numéro local, et le solde.
Le client du compte peut effectuer :
- une opération (retrait, versement, virement, paiement par chèques, ...) sur son compte
- ou consulter son solde et des opérations.
Compte client. C'est une sous-classe de Compte qui a des caractéristiques supplémentaires :
- le montant du découvert maximum autorisé,
- le gestionnaire auquel est rattaché le compte client,
- l'identité bancaire qui est construite à partir du code local, code du gestionnaire et code de l'agence.
Le client a aussi la possibilité de modifier le découvert maximum autorisé sur son compte.
Compte CB. Comme le compte client, il hérite des propriétés d'un compte normal, et dispose d'autres différentes :
- le code la carte bleue associée
- un retrait maximum hebdomadaire autorisé et la possiblité de le modifier,
- un attribut qui représente l'état actuel du compte : bloqué ou non,
- une méthode pour bloquer le compte si par exemple faute de découvert important dans la semaine, le client n'est plus autorisé à débiter de l'argent avec sa carte bancaire.
- une méthode débloquer.
- enfin un attribut état qui reflète l'état bloqué ou débloqué du compte.
Client . Il est identifié par son nom et son prénom.

En approfondissant notre réflexion sur les liaisons entre ces classes (qu'est ce qui circule entre le client et le compte, du compte au gestionnaire, ...), nous avons fait apparaître de nouvelles classes qui décrivent les opérations, consultations et résultat de ces transactions.
Soit :

des objets de transaction bancaire :
- Operation. Ce peut être une opération de retrait, de virement d'un compte vers un autre, de dépôt d'argent sur un compte, ....
  Elle prend en compte :
  - le montant de la transaction,
  - le compte source identifié par un numéro de compte bancaire : l'Identité Bancaire
  - le compte destinataire (pour les opérations de virement notamment) identifié de la même façon,
  - le numéro de chèque pour les paiements avec chéques.
  - la date de l'opération,
  - le libellé (retrait, virement, dépôt, ...),
  - une signature ,
  Nous avons rajouté pour des raisons (en partie de programmation), un attribut supplémentaire : la cible.
  Elle vaut 1 si l'opération est : source vers destinataire.
  elle vaut 0 si c'est l'inverse, ou s'il n'y a pas de destinataire comme pour les opérations de retrait et de dépôt d'argent.
  Ainsi, en prenant connaissance de la cible, une banque peut "dispacher" l'opération aux agences (et leur gestionnaire) source et destinataire qui respectivement, effectuent une opération de débit sur le compte source et une opération de crédit sur le compte du destinataire (s'il s'agit d' un virement).
- Consultation. Il y a deux types de consultation :
  - type 1 : consultation du solde,
  - type 2 : relevé des opérations.
- un objet "retour" des transactions effectuées : Compte Rendu.
  Il diffère selon les opérations et les consultations.
  Le client peut obtenir :
  - un premier compte rendu : son solde à la date du jour,
  - un deuxième compte rendu : un tableau des opérations effectuées à partir d'une date donnée.
- des objets qui permettent d'identifier un compte, et d'authentifier les transactions :
  - Identite Bancaire. C'est le numéro de compte bancaire.
    Il est composés des trois champs existant dans les R.I.B. du systéme français :
    - le code de la banque : 5 chiffres,
    - le code guichet (ou code de l'agence) : 5 chiffres,
    - le code local du client : 11 chiffres.
    Il permet d'identifier un compte dans son intégralité (banque? agence? client?)
  - Signature. C'est une signature correspondant à la signature papier Elle permet de valider une requête.

II.2.4.2 Ecriture en I.D.L.

Toutes les spécifications ont été décrites en I.D.L. pour être ensuite exploiter dans la construction des objets (implantation de leurs méthodes) .
Comme je l'avais expliqué dans la première partie, ce sont les interfaces des objets (signature des méthodes et attributs) que l'on présente en I.D.L.
Je tenais à préciser que outre la spécification en I.D.L. des objets définis plus haut, j'ai également écrit en I.D.L. une interface MaDate qui reprend la spécification de la classe Date existant en Java.
De plus, étant donné que le type vecteur n'existe pas en I.D.L., j'ai construit une séquence d'Operation que j 'ai appelée tabop. Tabop est un tableau d'opeartions, il est nécessaire dans l'écriture de l' interface CompteRendu car il apparait comme type retour de la méthode getReleve().

typedef sequence <Operation> tabop;

Le code en I.D.L. est disponible dans les annexes de ce document.

Explications techniques

Les interfaces écrites en I.D.L. sont "tapées" dans un fichier texte puis sauvées dans mon répertoire de travail sous l'extension idl.
Ce fichier idl a ensuite été compilé (commande : idl AppBanque.idl) par le compilateur d'I.D.L. vers Java fournit par Orbix Web.
Si des erreurs sont apparues à la compilation, on les corrige dans le fichier idl et on le compile à nouveau jusqu'à ce qu'il n'y ait plus aucune erreur.
Lorsque la compilation s'est déroulée correctement, Orbix Web a généré des fichiers Java incluant le corps des squelettes et stubs utiles à la programmation de l'application. Par défaut ces fichiers sont "déposés" dans un répertoire crée par orbix Web à cet effet : java_output
Vous pouvez visualiser le contenu de ces fichiers en annexes.

II.2.5 Réalisation d'un sous-ensemble de classes

II.2.5.1 Fichiers généres par le compilateur d'Orbix Web

Le compilateur d'I.D.L. a produit plusieurs constructions Java qui correspondaient aux définitions I.D.L.. Ces constructions peuvent être scindées en deux groupes :

une première partie va permettre aux clients d'acceder à un objet à travers l'interface de cet objet.
une deuxième partie inclue l'ensemble des constructions qui permettent à un objet d'être implanté par le serveur.
une troisième partie sert à établir le lien entre le client et le serveur.

Première partie

Cette partie contient :

une interface java pour chaque interface I.D.L.
des classes Java qui implantent les méthodes définies dans l'interface générée.
Ces classes fournissent les fonctionnalités de la souche de communication cliente (le stub).
_GestionnaireStub
Il y a autant de _stub java que d'interfaces I.D.L.

Deuxième partie

contenu :

une classe java utilisée par orbix Web qui propose les fonctionnalités de la souche serveur (le skeleton).
Il s'agit de répartir les requêtes arrivant sur le serveur de l'application vers l'implantation des objets. (remarque : cette une classe qui n'a pas besoin d'être comprise du développeur).
_gestionnaireSkeleton
une classe java abstraite qui sert à implanter l'interface d'un objet côté serveur .
C'est ce que l'on appelle " l'approche Implbase ".
_GestionnaireImplBase
deux autres classes employées dans " l'approche TIE " : approche d'implantation des interfaces spécifique à Orbix et non standardisée.
Classe _tie_Gestionnaire et classe _GestionnaireOperations

Nous reviendrons plus tard sur ces deux approches afin de déterminer la mieux appropriée à notre application

Troisième partie

Deux types de classes générées :

les classes Helper. Elles permettent de manipuler les types définis dans l'I.D.L..
Ex : GestionnaireHelper.
les classes Holder .

II.2.5.2 Approche-Implbase ou Approche-TIE ?

Comparaison

Orbix Web fournit deux méthodes pour implanter une interface I.D.L.
Ces deux approches sont :

l' approche Implbase qui utilse l'héritage, c'est l'approche standard C.O.R.B.A.
l'approche TIE qui utilise la "délégation" est préférée pour construire les applications Java.

Le langage Java ne supporte pas l'héritage multiple.
Ainsi, utiliser l'héritage que l'approche ImplBase impose sur l'implantation des classes limite la fléxibilité de ces classes.
De plus, cela élimine la possibilité de réutiliser les implantations existantes des interfaces dérivées.
Par contre, il n'y a pas de restriction dans l'approche TIE , et c'est pour cela que nous l'avons choisie.
Etant donnée la compléxité d'héritage des classes de notre application, j'ai choisi d'implanter mes objets avec l'approche TIE.

Mécanisme d'implantation d'un objet dans l'approche TIE

Ce mécanisme n'est possible que si l'on a au préalable implementé une interface I.D.L.
Regardons le mécanisme sur le schéma suivant :

Le compilateur d'I.D.L. d'Orbix a génèré une classe tie java pour chaque interface I.D.L.
Le fichier généré est nommé "_tie_xxx.java".
Un objet qui implante l'interface I.D.L. est passé en paramètre au constructeur de la classe tie.
On définit ensuite une classe qui va implanter les opérations et attributs définis dans l'interface I.D.L.
exemple de classe : GestionnaireImplementation
Cette classe n'a pas besoin d'hériter de toutes les classes générées automatiquement.
Elle doit simplement implanter l'interface java : _gestionnaireOperations.
Ensuite, le programmeur instancie un objet tie : _tie_gestionnaire, en passant l'objet implanté GestionnaireImplementation au constructeur.
A la création des objets tie, il est possible de passer un second paramètre au constructeur de type String. Ce marqueur permet ainsi d'identifier de façon unique l'objet instacié sur le serveur.

GestionnaireImplementation g=new GestionnaireImplementation();
Gestionnaire gestCA= new _tie_Gestionnaire(g,"CA");

C'est une alternative au service de nommage.

Exemple implanté

[ cf sources annexes]

II.2.5.3 Classes implantées

Des classes ClassImplementation ont été écrites pour chaque interface I.D.L.
Ces classes sont composées d'un constructeur, d'attributs et de l'implantation des méthodes spécifiées dans l'I.D.L.
Chacune implante _ClassOperations : la classe générée par le compilateur en accord avec l'interface écrite en I.D.L.
C'est le principe de l'approche tie.
Tous les sources sont disponibles dans les annexes.
La prochaine étape consiste à écrire les programmes serveur et client. Puis décider d'une interface d'utilisation de l'application distribuée.

II.2.6 Classes et interfaces de test des classes implantées

Dans cette étape , j'écrits les deux classes suivantes :

la classe ApplServeur qui contient le code exécutable du programme serveur.
la classe ApplClient qui contient le code nécessaire à l'implantation du client.
En fait comme vous le verrez plus loin, j'ai aussi écrit un deuxième programme client qui lui plus complet, inclue une ébauche d'une interface utilisateur.

Je vous détaille ci-dessous l'implantation de ces classes tests.

II.2.6.1 Ecriture du programme serveur : classe ApplServeur

Mon serveur fournira deux gestionnaires de comptes :

un pour la banque du Crédit Agricole,
un autre associé à la banque du Crédit Lyonnais.

Le code de mon serveur instanciedonc deux objets Gestionnaire ga et gc avec leurs objets tie associés : gestCA et gestCL.
Ces objets sont nommés respectivement CA et CL à leur construction.
Ainsi les clients pouront invoquer l'un ou l'autre, en se "liant" avec eux sur le serveur par appel de la méthode :

bind ("nom de l'objet tie : nom du serveur d'objets",
      "adresse de la machine serveur")

Cette méthode indispensable au programme client est davantage développée dans la section suivante.
Revenons à notre programme serveur, chaque objet instancié doit être connecté au bus. Sinon, il sera impossible pour le serveur de gérer les invocations clientes arrivant pour ces objets.
Il y a deux méthodes disponibles dans Orbix Web pour connecter les objets à l'O.R.B :

utiliser ORB.connect() et ORB.disconnect().
Ces méthodes sont définies dans la spécification C.O.R.B.A. Ce sont des méthodes standards.

L'O.R.B continue d'appliquer les méthodes invoquées sur les objets-tie jusqu'à ce qu'ils soient déconnectés (avec ORB.disconnect(objet-tie)).
ou bien utiliser _CORBA.Orbix.impl_is_ready.
C'est une méthode spécifique à Orbix Web.
Elle indique que le serveur a terniné l'initialisation d'un ensemble d'objets, et qu'il est maintenant prêt pour recevoir les requêtes sur ces objets.
Cette méthode "bloque" le serveur jusqu'à ce que des évènements aient lieu.
Pour permettre au serveur d'être lancé soit de façon automatique (à partir du client) soit manuellement, il est recommandé de passer le nom du serveur en paramètre de impl_is_ready(). _CORBA.Orbix.impl_is_ready(String nom du serveur)

J'ai utilisé ORB.connect(gestCA) et ORB.connect(gestCL) pour connecter mes objets gestionnaire au bus.
Le serveur a mis ses objets à disposition puis se met en veille (blocage du processus).
Aprés un time out (delai), le processus serveur se reveille et déconnecte ses objets
est d'enregistrer Le serveur d'objets est enregistré auprés du référentiel des implantations par la commande : putit -java nom du serveur (dans une console)
Le code de la classe AppLServeur est visualisable dans les annexes

II.2.6.2 Ecriture du programme client et interface d'utilisation

Du côté client, nous pouvons utiliser et invoquer des traitements sur les gestionnaires disponibles sur le serveur : créer un compte, déposer de l'argent, consulter le solde, ...etc.
Pour tester mon application et vérifier si les méthodes que j'avais écrites étaient correctes, j'ai d'abord écrit un premier programme client : classe ApplClientDemo.
Dans ce programme de test, les opérations effectuées sont :

initialisation de l'O.R.B.
connexion aux gestionnaires gestCA et gestCL sur le serveur,
création d'un compte (c1) au Crédit Agricole,
opération de retrait de 400 F sur c1,
dépôt de 56.50 F sur c1,
création d'un compte c2 au Crédit Lyonnais,
virement de 50 F de c1 sur c2,
consultaion relevé des opérations de c1,
consultation du solde de c1,
consultation du solde de c2,

Ce programme fait rarement intervenir l'utilisateur.
En effet,c'était avant tout une phase de test qui consistait à vérifier la cohésion et la validité des méthodes des objets que j'avais implantées auparavant.
J'ai donc élaboré cette première application cliente dans un souci de fiabilité en testant au fur et à mesure les opérations les plus élémentaires sur un compte.
Une fois cette étape de validation terminée, je me suis lancée dans l'écriture d'un autre programme client intégrant une mini-interface utilisateur. Il s'agit de la classe ApplClient
Ainsi, un client peut manipuler l'application à l'aide de l'interface graphique. La gestion des évènements dans cette interface a en partie été gérée.
De plus, contrairement au premier programme client, j'ai "éclaté" la méthode main()en plusieurs méthodes invoquées à la construction de AppClientDemo.
Cette classe implantée permet :

de mettre en place une interface utilisateur,
d'ouvrir un compte,
de consulter ou d'effectuer une transaction bancaire.

Bien sûr, cette réalisation peut sembler minimaliste mais les bases peuvent être celles d'une réelle application distribuée.

Détails de programmation

Regardons plus précisément la méthode de connexion du client avec le serveur.
Cette méthode commune aux deux programmes clients est la méthode standard pour se lier avec les objets sur le serveur.
En effet bind() est utilisée pour créer les souches de communication pour les objets qui ont été crées sur le serveur.
La création d'un proxy dans l'espace d'adressage du client permet aux opérations d'être invoquées sur l'objet ciblé.
Lorsque l'opération est invoquée sur le proxy, Orbix web transmet automatiquement la requête à l'objet ciblé.
Bind() est une méthode statique qui est automatiquement générée par le compilateur d'I.D.L.pour chaque classe idl-java. Pour chaque interface, la forme entière de bind() est déclarée dans la classe java nom de la classe suivi de Helper.
La méthode bind() peut être utilisée pour spécifier exactement l'objet requis, ou bien en utilisant les paramètres par défaut.
Orbix web permet une certaine liberté dans le choix de l'objet.
Dans mes programmes clients, j'ai choisi de paramétrer la méthode bind() comme suit :
xxxHelper.bind(String nom de l'objet ciblé:String nom du serveur, String adresse de la machine serveur)
Exemple :

GestionnaireHelper.bind("CA:ApplServeur","mass-handicap.univ-tlse2.fr");

CA est le nom de l'objet Gestionnaire (du Crédit Agricole) disponible sur le serveur.
Applserveur est le serveur d'objets,
mass-handicap.univ-tlse2.fr : adresse de la machine où le serveur est implanté

Schéma explicatif

Par simplicité, j'ai fait en sorte que mon client crée lui aussi des objets : Client, Operation, consultation.
Cependant, ce n'est pas la méthode qu'il faut adopter dans le cadre général, en effet l'on disposera plutôt de plusieurs serveurs d'objets : un serveur de gestionnaire, un serveur de clients, un serveur d'opérations ...ect.
Je n'ai implanté qu'un serveur de gestionnaires sur lesquels les objets crées côté client peuvent invoquer des méthodes.

Trace d'exécution sur le serveur

(cf annexe)

Difficultés posées par la distribution

Durant la réalisation de mon application distribuée, j'ai rencontré plusieurs difficultés liées à la distribution. Ces problèmes sont d'ordre spatial et temporel.

Problèmes liés à l'espace

Ma première grande difficulté a été de savoir comment répartir l'information.
Sur quel site (client ou serveur ?) les objets doivent être implantés, crées ou utilisés par les acteurs du système réparti.
En effet, dans une architecture client / serveur, le partage et la mobilité de l'information et des programmes contribuent au bon fonctionnement d'une application distribuée.
Il aurait été interessant dans mon application de créer plusieurs serveurs d'objets.

Un serveur de gestionnaires fournirait un gestionnaire pour chaque banque,
Un serveur de comptes associés à un gestionnaire,
Un serveur de clients,
... etc.

Or mon application ne fonctionne pour l'instant qu'avec un unique serveur d'objets : le fournisseur de gestionnaires.
Le client sans le savoir crée lui-même les autres objets entrant dans la "composition" des requêtes.
Cette implantation ne gère donc pas au mieux l'espace de distribution, et engendre alors des problèmes temporels.

Problèmes liés au temps

Si les ressources sont mal réparties dans l'application, cela peut "alourdir" et "ralentir" le routage de l'information.
Mon application étant succinte, je ne me suis pas vraiment rendu compte de ces problèmes temporels.
Par ailleurs, il faudrait aussi vérifier un ensemble de critères théoriques tels que la fiabilité, l'intégrité, la sécurité des données et la synchronisation des processus.

CONCLUSION

Conclusion générale

C.O.R.B.A. semble être la solution optimale en réponse aux problèmes d'hétérogénéité d'applications distribuées.
En effet, en intégrant le langage I.D.L.,il assure la compatibilité d'applications différentes.
Et d'autre part, son O.R.B. contribue à la portabilité de celles-ci.
Toutefois, lors de la construction d'une application répartie, il faut éviter au maximum d'utiliser les mécanismes propriétaires à un bus (méthode bind(), connect(), ...).
Effectivement, cela limite l'extensibilité de l'application et l'interopérabilité avec d'autres environnements.

Conclusion personnelle

Le sujet de stage qui m'a été proposé correspondait largement à mes attentes, en matière de recherche et de développement dans un contexte nouveau pour moi : les systèmes distribués.
En effet, à travers ce stage j'ai pu découvrir le standard C.O.R.B.A. pour la réalisation d'applications réparties. Parallèlement, j'ai également approfondi mes connaissances sur le langage de programmation orientée objet : Java.
Dans la conception d'un système distribué bancaire, j'ai été amenée à manipuler non sans mal Orbix Web de IONA qui fournit un environnement logiciel pour la construction d'applications distribuées.
Il m'a été en effet difficile au départ de contourner les problèmes techniques posés par Orbix web. Cependant, ce logiciel était trés bien documenté, et c'est en partie grâce à lui que j'ai fait mes premiers pas dans l'environnement C.O.R .B.A.
Mais C.O.R.B.A., ce n'est pas simplement un bus logiciel d'objets répartis, c'est aussi l'intégration d'un langage de description d'interfaces : l'I.D.L. que j'ai appris à connaître.
Enfin, étudier tous les mécanismes de distribution intervenant dans une architecture client / serveur était difficile mais j'ai pris plaisir à y réfléchir dessus.
Mon seul regret est de ne pas avoir mener à terme la réalisation du système bancaire distribué. faute de temps.
De plus, j'aurais également souhaité achever l'interface graphique d'utilisation.
Toutefois, j'ai réalisé avec satisfaction cette mini-application qu'il est possible de compléter par la suite.
Tout ce travail a été alimenté par des réunions avec mes responsables encadrant, et les consultations de documentations sur Internet. Tout cela m'a permis d'avancer avec confiance et enchantement.

ANNEXES

I.H.M.

CREATION D'UN COMPTE

TRAITEMENTS POSSIBLES

Menu / Retrait

Menu / Consultation

TRACE D'EXECUTION

[ IT_daemon: New Connection (mass-handicap.univ-tlse2.fr:1075) ]
-- Receive thread started for @:*
[ Consulting Object Table by type IT_daemon ]
[ Consulting Object Table by type IT_daemon ]
[ Consulting Object Table by marker 0 ]
[ Consulting Object Table by marker 0 ]
[ Consulting Object Table by marker 0 ]
[Incoming Request getIIOPDetails to object 0 of type IT_daemon]
[ Consulting Object Table by marker 0 ]
Launching a server with the following:

C:\jdk1.1.6\bin\java.exe 
-classpath 	c:\mesdoc~1\visual~1\06-01-99;C:\Iona\OrbixWeb3.0\classes;
			C:\jdk1.1.6\lib\classes.zip 
-Dorbixweb.env=tcp:xdr:2005:ApplServeur:-889265217:*:*:shared_m::1571:2005 
ApplServeur 
		
[ Consulting Object Table by marker 0 ]
[ Consulting Object Table by marker 0 ]
-- Outgoing Reply to getIIOPDetails from object 0 of type IT_daemon]
gestCA cree => _tie_Gestionnaire@16ccb5
[ ApplServeur: New Connection (mass-handicap.univ-tlse2.fr:1077) ]
gestCL cree => _tie_Gestionnaire@16d29a
serveur en attente
pause
[ Consulting Object Table by marker 0 ]
[ Consulting Object Table by marker 0 ]
[ Consulting Object Table by marker 0 ]
[Incoming Request getIIOPDetails to object 0 of type IT_daemon]
[ Consulting Object Table by marker 0 ]
[ Consulting Object Table by marker 0 ]
[ Consulting Object Table by marker 0 ]
-- Outgoing Reply to getIIOPDetails from object 0 of type IT_daemon]
banque : CréditAgricole
conversion gest
conversion ok => _tie_Gestionnaire@16d5c3
identite bancaire => 001001
cptimplementation ok
CompteClient ?
CompteClient ok
code guichet du gestionnaire gestCA: 001
[ Consulting Object Table by marker 2 ]
code guichet: 001
code local: 001
identite bancaire: 001001
libelle du cpte :katia
liste des comptes : {}
identite bancaire: 001001
taille de liste_compte: 1
elnts de liste_compte =>{_tie_IdentiteBancaire@16d613=_tie_CompteClient@16d665}
___________________________________________________________
ajout d op ds vecteur d operation
ajout op ok
[New IIOP Connection (mass-handicap.univ-tlse2.fr,1074, null,null,pid=0) ]
valeur de la cible : 0
debiter cptdsrce
solde de cpt source(c1): 320.0
montant de l op: 300.0
debit ok : 20.0
___________________________________________________________
ajout d op ds vecteur d operation
ajout op ok
valeur de la cible : 1
crediter cptdest
solde de cpt dest(c2): 20.0
montant de l op: 56.5
credit ok : 76.5
banque : CréditLyonnais
conversion gest
[ Consulting Object Table by marker 5 ]
conversion ok => _tie_Gestionnaire@16dc33
identite bancaire => 002001
cptimplementation ok
CompteClient ?
CompteClient ok
code guichet du gestionnaire gestCA: 002
code guichet: 002
code local: 001
identite bancaire: 002001
libelle du cpte :sonia
liste des comptes : {}
identite bancaire: 002001
taille de liste_compte: 1
elnts de liste_compte =>{_tie_IdentiteBancaire@16dc8d=_tie_CompteClient@16dcee}
[ Consulting Object Table by marker 2 ]
___________________________________________________________
ajout d op ds vecteur d operation
ajout op ok
valeur de la cible : 0
debiter cptdsrce
solde de cpt source(c1): 76.5
montant de l op: 50.0
debit ok : 26.5
___________________________________________________________
ajout d op ds vecteur d operation
ajout op ok
valeur de la cible : 1
crediter cptdest
solde de cpt dest(c2): 100.0
montant de l op: 50.0
credit ok : 150.0
debut consultation
code local du cpt consulte: 001
codelocal ok
type de la consultation: 2
type =2 ok
date de la consultation mon 14 jun 99
 MaDateImplementation ok
[ Consulting Object Table by marker 7 ]
 MaDate ok
tab des op [_OperationStub@16d827, _OperationStub@16da7d, _OperationStub@16df2d]
taille de tabop 3
op 0 : _OperationStub@16d827
tab releve[_OperationStub@16d827]
taille de tabop 3
op 1 : _OperationStub@16da7d
tab releve[_OperationStub@16d827, _OperationStub@16da7d]
taille de tabop 3
op 2 : _OperationStub@16df2d
tab releve[_OperationStub@16d827, _OperationStub@16da7d, _OperationStub@16df2d]
taille de tabop 3
releve ok
debut afficher
nb d'opérations effectuées : 3
0
op ok
1
op ok
2
op ok
1 ème opération : retrait montant : 300.0
2 ème opération : dépot montant : 56.5
3 ème opération : virement montant : 50.0

debut consultation
code local du cpt consulte: 001
codelocal ok
type de la consultation: 1
type =1 ok
[ Consulting Object Table by marker 9 ]
solde du cpte c1 26.5
[ Consulting Object Table by marker 8 ]
debut consultation
code local du cpt consulte: 001
codelocal ok
type de la consultation: 1
type =1 ok
[ Consulting Object Table by marker 11 ]
solde du cpte c1 150.0
[ Consulting Object Table by marker 10 ]
[ End of IIOP connection (mass-handicap.univ-tlse2.fr:1074) ]
[ IT_daemon: End of IIOP connection (mass-handicap.univ-tlse2.fr:1075) ]
[ ApplServeur: End of IIOP connection (mass-handicap.univ-tlse2.fr:1077) ]
deconnexion

SOURCES

AppBanque.idl  
-------------------------------------------------------------------------------
//!!! #include date.idl
interface MaDate{
    string showDate();
    boolean after(in MaDate d);
};
interface Consultation;
interface Gestionnaire;
interface Agence;
interface CentreCB{};
interface Compte;
interface CompteClient;
interface CompteCB;
interface IdentiteBancaire;
interface CompteRendu;
interface Operation;
interface Consultation;
typedef sequence  tabop;

interface Client{
    string getNom();
    string getPrenom();
};

interface Agence{
    string getNom();
    Gestionnaire getGestionnaire();
};
    
interface Signature{
    string getNom();
};

interface IdentiteBancaire{
    string getCodeBanque();
    string getCodeGuichet();
    string getCodeLocal();
};

interface Gestionnaire {
    string getLibelle();
    string getNumero();
    Agence getAgence();
    //string getCodeInit();
    //void setCodeInit(in string nvcodinit);
    CompteClient creerCompteClient(in Client cli,
                    in string lib,in float sold,
                    in string codelocal,
                      in float decouvertMaximum);
    void fermerCompte(in IdentiteBancaire ib);
    CompteClient getCompte(in IdentiteBancaire ib);
    void migrerCompte(in CompteClient cptcli, in Agence agence);
    void creerCB(in Client cli,in CompteClient cptcli);
    void fermerCB();
    void executer(in Operation operation);
    
};

interface CompteRendu {
     float getSolde();
     MaDate getDate();
     string getLibelle();
     tabop getReleve();
     string showReleve();
};  
      
interface Compte {
    
    Client getClient();
    string getLibelle();
    string getNumero();
    float getSolde();
    CompteRendu effectuer(in Operation operation);
    CompteRendu consulter(in Consultation consultation);
    
};

interface CompteClient : Compte {
    void setDecouvertMaximum(in float nvdecouvert);
    Gestionnaire getGestionnaire();
    float getDecouvertMaximum();
    IdentiteBancaire getIb();
    
};

interface CompteCB : Compte {
    void setRetraitMaxhebdo(in float nvretrait);
    CompteClient getCompteClient();
    boolean etat();
    void bloquer();
    void debloquer();
    float getRetraitMaxHebdo();
    long getCode();
    
};

interface Operation {
    IdentiteBancaire getSource();
    IdentiteBancaire getDestination(); 
    float getMontant();
    string getLibelle();
    string getNumCheque();
    long getCible();
    void setCible(in long nvcible);
    MaDate getDate();
    Signature getAuthentification();
  };
 
interface Consultation {
    long getType();
    IdentiteBancaire getIb();
 };

CompteImplementation.java  
-------------------------------------------------------------------------------
import java.util.*;
import java.util.Date;
import javax.swing.*;
import org.omg.CORBA.SystemException;

/**
 * implementation de l'objet compte bancaire
 */
public class CompteImplementation implements _CompteOperations {

    //membres
    Client client;
    String libelle;
    String numero;
    float solde;
    /**
     * vecteur des opérations effectuées sur le compte bancaire
     */
    Vector tabop;
    
    //constructeur
    public CompteImplementation(Client cli,
                String lib,float sold,String numlocal) {
        this.client=cli;
        this.libelle=lib;
        this.solde=sold;
        this.numero=numlocal;
        this.tabop=new Vector();
    }     
                     
    
    //effectuer une operation
    public CompteRendu effectuer(Operation op) {
        MaDateImplementation dateimpl=new MaDateImplementation();
        MaDate datecourante=new _tie_MaDate(dateimpl);
        tabop.addElement(op);
        //!!!exceptions si cible!=0 ou 1
        if (op.getCible()==0)
            this.solde-=op.getMontant();
        if (op.getCible()==1)
            this.solde+=op.getMontant();
        String libop=op.getLibelle()+" de "+op.getMontant()+" 
                    effectué le "+ op.getDate();
        CompteRenduImplementation cr=
            new CompteRenduImplementation(libop,datecourante);
        CompteRendu cptrendu=new _tie_CompteRendu(cr);
        return(cptrendu);
    }
    
        
    /**
     * consulter soit le solde soit le releve des opérations,
     * retourne un compte rendu qui differe selon 
     * le type de la consultation.
     * */
    public CompteRendu consulter(Consultation cons) {
        System.out.println("debut consultation");
        MaDateImplementation d=new MaDateImplementation();
        MaDate currentDate=new _tie_MaDate(d);
        Vector listop=new Vector();
        int i;
        //compte consulte
        IdentiteBancaire ibc=cons.getIb();
        System.out.println("code local du cpt consulte: "
                +ibc.getCodeLocal());
        //IdentiteBancaire ib=this.getIb();
        //si bon codelocal
        if (ibc.getCodeLocal()==this.getNumero()){
            System.out.println("codelocal ok");
            int a=cons.getType();
            System.out.println("type de la consultation: "+a);
            //type=1 => solde
            if (cons.getType()==1){
                System.out.println("type =1 ok");
                //retourne un cpte rendu(solde+date)
                float s=this.getSolde();
                System.out.println("solde du cpte c1 "+s);
                CompteRenduImplementation cptr1=null;
                try{
                cptr1=new CompteRenduImplementation(s,currentDate);
                }
                catch (SystemException se){
                System.out.println("Exception :"+se.toString());
                }
                CompteRendu cptrendu1
                                        =new _tie_CompteRendu(cptr1);
                
                return(cptrendu1);
            }//fin if1
            
            //type=2 => releve
            if (cons.getType()==2){
                System.out.println("type =2 ok");
                /*String dateop=JOptionPane.showInputDialog(null,
                    "relevé à partir de quelle date ?");
                    System.out.println("...." + dateop );*/
                String dateop="mon 14 jun 1999";
                MaDateImplementation da= new MaDateImplementation(dateop);
                System.out.println(" MaDateImplementation ok");
                MaDate dt=new _tie_MaDate(da);
                System.out.println(" MaDate ok"+dt.showDate());
                //recuperer le vecteur d op
                System.out.println("tab des op "+tabop);
                System.out.println("taille de tabop "+tabop.size());
                for(i=0;i<(tabop.size());i++){
                    Operation o=(Operation)tabop.elementAt(i);
                    System.out.println("op "+i+" : "+o);
                    MaDate mydate=(MaDate) o.getDate();
                    System.out.println("date pr releve =>"+mydate.showDate());
                    /*String res= (madate.after(d))? "yes" : "no" ;
                    System.out.println("date releve after? "+res) ;
                    if ( madate.after(d) ){*/
                        System.out.println("after ok");
                        listop.addElement(o);
                        System.out.println("tab releve"+listop);
                        System.out.println("taille de tabop "+tabop.size());
                            
                }
                System.out.println("releve ok");
                //retourne un cpte rendu(releve+date)
                CompteRenduImplementation cptr2=null;
                try{
                    cptr2=new CompteRenduImplementation(listop,dt);
                }
                catch (SystemException se){
                System.out.println("Exception : "+se.toString());
                }
                CompteRendu cptrendu2=new _tie_CompteRendu(cptr2);
                
                return(cptrendu2);
            }//fin if2
        System.out.println("erreur type consultation");
        return(null);
        }    
        System.out.println("erreur codelocal");
        return(null);
    }        
    
    public Client getClient() {
        return(this.client);
    }
    
    public String getLibelle(){
        return(this.libelle);
    }

    public String getNumero() {
        return(this.numero);
    }
        
    public float getSolde() {
        return(this.solde);
    }
    
    
}

CompteClientImplementation.java  
-------------------------------------------------------------------------------
import java.util.*;
import java.math.*;

/**
 * Impléméetation d'un compte bancaire client,
 * qui ne possède pas de carte bancaire.
 */

public class CompteClientImplementation extends CompteImplementation
    implements _CompteClientOperations{
    
    //membres
    IdentiteBancaireImplementation ident;
    IdentiteBancaire ib;
    Gestionnaire gestionnaire; 
    float decouvertMaximum;
    
    
    
    //constructeur
    public CompteClientImplementation(Client cli,String lib,float sold,
                                        String numlocal, Gestionnaire gest,
                                        float decouvertmax) {
        super(cli,lib,sold,numlocal);
        this.decouvertMaximum=decouvertmax;
        this.gestionnaire=gest;
        //!!!codeBanque=""
        this.ident=
            new IdentiteBancaireImplementation("",gest.getNumero(),numlocal);
        this.ib=new _tie_IdentiteBancaire(ident);
        System.out.println("identite bancaire => "+ib.getCodeGuichet()
                            +ib.getCodeLocal());
    }
    
    
    /**
     */
    public CompteRendu effectuer(Operation op) {
        System.out.println("___________________________________________________________");    
        MaDateImplementation dateimpl=new MaDateImplementation();
        MaDate datecourante=new _tie_MaDate(dateimpl);
        System.out.println("ajout d op ds vecteur d operation");
        (this.tabop).addElement(op);
        System.out.println("ajout op ok");
        System.out.println("valeur de la cible : "+op.getCible());
        
        //verification ib
        //if ((op.getSource()).getCodeLocal()==this.getNumero()){
        
        //si src=>dest
        if (op.getCible()==0){
            if (this.getDecouvertMaximum()>=(this.solde-op.getMontant())){
                System.out.println("debiter cptdsrce");
                System.out.println("solde de cpt source(c1): "+this.solde);
                System.out.println("montant de l op: "+op.getMontant());
                this.solde-=op.getMontant();
                System.out.println("debit ok : "+this.solde);
            }
            else {
            String erreur="vous ne disposez pas de cette somme sur votre compte";
            CompteRenduImplementation crimpl=
            new CompteRenduImplementation(erreur,datecourante);
            CompteRendu cpr=new _tie_CompteRendu(crimpl);
            return(cpr);
            }
        }// fin cible=0
            
        //si dest=>src
        if (op.getCible()==1) {
            System.out.println("crediter cptdest");
            System.out.println("solde de cpt dest(c2): "+this.solde);
            System.out.println("montant de l op: "+op.getMontant());
            this.solde=(this.solde + op.getMontant());
            System.out.println("credit ok : "+this.solde);
        }//fin si clible=1
        
        String ok=op.getLibelle()+" de "+op.getMontant()+" effectué le "
                +op.getDate();
        CompteRenduImplementation cimpl=
            new CompteRenduImplementation(ok,datecourante);
        CompteRendu compterdu=new _tie_CompteRendu(cimpl);
        return(compterdu);
        //}
        //return("erreur");
    }
    
    //modifier le decouvert maximum
    public void setDecouvertMaximum(float nvdecouvert) {
        this.decouvertMaximum=nvdecouvert;
    }

    public Gestionnaire getGestionnaire() {
        return gestionnaire;
    }

    public float getDecouvertMaximum() {
        return(this.decouvertMaximum);
    }
    
    public IdentiteBancaire getIb(){
        return(this.ib);
    }
}

CompteCBImplementation.java  
-------------------------------------------------------------------------------
import java.util.*;

public class CompteCBImplementation extends CompteImplementation
    implements _CompteCBOperations{
    //membres
    CentreCB centreCB;
    float retraitMaxHebdo;
    CompteClient compteClient;
    int code;
    boolean lock; //etat bloque ou non
    
   
    //constructeur
    public CompteCBImplementation(Client cli,String lib,float sold,String num,
                                  CentreCB centrecb,float retraitmaxhebdo,
                                  CompteClient cptclient,int cod){
        super(cli,lib,sold,num);
        this.centreCB=centrecb;
        this.retraitMaxHebdo=retraitmaxhebdo;
        this.compteClient=cptclient;
        this.code=cod;
        this.lock=false;
    }
    
    //etat du compte
    public boolean etat(){
        return(this.lock);
    }
    
    //bloquer le compte                
    public void bloquer() {
        this.lock=true;
    }
    
    //debloquer le compte
    public void debloquer() {
        this.lock=false;
    }
                        
    //!!! methode effectuer a redefinir 
    //si bloquer ou pas, + retraitMaxHebdo ds sem courante(lundi=>)
    public CompteRendu effectuer(Operation op) {
        MaDateImplementation dateimpl=new MaDateImplementation();
        MaDate datecourante=new _tie_MaDate(dateimpl);
        tabop.addElement(op);
        //si compte non bloque
        if (this.etat()){
            //si src=>dest
            //!!!!mqe test si cible!=0 ou 1
            if (op.getCible()==0){
                //!!!lundi=>op.getdate() som(op.mont)=(op.getMontant()))
                    this.solde-=op.getMontant();
                else {
                    String libop="retrait refuse";
                    CompteRenduImplementation cr
                        =new CompteRenduImplementation(libop,datecourante);
                    CompteRendu cptrendu=new _tie_CompteRendu(cr);
                    return(cptrendu);
                }//fin else
                
            }  //fin if cible=0
            
            //si dest=>src
            if (op.getCible()==1)
                this.solde+=op.getMontant();
            
            String libo=op.getLibelle()+" de "+op.getMontant()
                        +" effectué le "+op.getDate();
            CompteRenduImplementation crendu=
                new CompteRenduImplementation(libo,datecourante);
            CompteRendu cprendu=new _tie_CompteRendu(crendu);
            return(cprendu);
        } //fin état
            
        
        String l="compte bloqué";
        CompteRenduImplementation rendu
            =new CompteRenduImplementation(l,datecourante);
        CompteRendu cp=new _tie_CompteRendu(rendu);
        return(cp);
    }
    
    public CentreCB getCentreCB(){
        return(this.centreCB);
    }

    public float getRetraitMaxHebdo() {
           return(this.retraitMaxHebdo);
    }
    
    public void setRetraitMaxhebdo(float nvretrait){
        this.retraitMaxHebdo=nvretrait;
    }
    
    public CompteClient getCompteClient() {
        return(this.compteClient);
    }
    public int getCode() {
        return(this.code);
    }
    
    
}

CompteRenduImplementation.java  
-------------------------------------------------------------------------------
import java.util.Date;
import java.util.*;
import javax.swing.*;

public class CompteRenduImplementation implements _CompteRenduOperations{

    //membres
    String libelle;
    float solde;
    MaDate date;
    Vector taboperations;
    
    //constructeur pr op effectuée
    public CompteRenduImplementation(String lib,MaDate dat){
        this.libelle=lib;
        this.date=dat;
    }
    
    //constructeur solde
    public CompteRenduImplementation(float sold,MaDate dat){
        this.solde=sold;
        this.date=dat;
    }
    
    //constructeur releve
    public CompteRenduImplementation(Vector top,MaDate dat){
        this.taboperations=top;
        this.date=dat;
    }
    
    public String getLibelle(){
        return(this.libelle);
    }
    
    public float getSolde(){
        return(this.solde);
    }
    
    public Operation[] getReleve(){
        Operation[] tab = new Operation[taboperations.size()];
        taboperations.copyInto(tab);
        return tab;
    }
    
    public MaDate getDate(){
        return(this.date);
    }
    
    //parametre le tablo d op
    public String showReleve(){
        System.out.println("debut afficher");
        String s="";
        int taille=taboperations.size();
        System.out.println("nb d'opérations effectuées : "+taille);
        for(int i=0;i montant : "+o.getMontant()+"\n";
        }
        System.out.println(s);
        return(s);
    }//fin afficher
    

}

OperationImplementation.java  
-------------------------------------------------------------------------------
import java.util.Date;
import java.util.*;

public class OperationImplementation implements _OperationOperations{

    //membres
    IdentiteBancaire ibsource;
    IdentiteBancaire ibdest;
    float montant;
    String numcheque;
    String libelle;
    int cible;
    Signature signature;
    MaDate date;
    
    //constructeur pour les opérations de virement
    public OperationImplementation(int cib,IdentiteBancaire ibs,
                                    IdentiteBancaire ibd,float mont,String lib,
                                    Signature sign,MaDate dat){
    
        this.cible=cib;
        this.ibsource=ibs;
        this.ibdest=ibd;
        this.montant=mont;
        this.signature=sign;
        this.libelle=lib;
        this.date=dat;
    }
    
    //constructeur pour les opérations de chèques
    public OperationImplementation(int cib,IdentiteBancaire ibs,
                                IdentiteBancaire ibd,float mont,
                                String lib,String numc,Signature sign,
                                MaDate dat){
        this.cible=cib;
        this.ibsource=ibs;
        this.ibdest=ibd;
        this.montant=mont;
        this.numcheque=numc;
        this.signature=sign;
        this.date=dat;
    }
    
    //constructeur pour les opérations de CB
    public OperationImplementation(int cib,IdentiteBancaire ibs,
                                    float mont,String lib,
                                    Signature sign,MaDate dat){
        this.cible=cib;
        this.ibsource=ibs;
        this.libelle=lib;
        this.montant=mont;
        this.signature=sign;
        this.date=dat;
    }
    
    public int getCible(){
        return(this.cible);
    }
    public void setCible(int nvcible){
        this.cible=nvcible;
    }
    
    public IdentiteBancaire getSource(){
        return(this.ibsource);
    }
    
    public IdentiteBancaire getDestination(){
        return(this.ibdest);
    }
    
    public float getMontant() {
        return(this.montant);
    }
    
    public MaDate getDate(){
        return(this.date);
    }
    
    public String getLibelle() {
           return(this.libelle);
    }

    
    public String getNumCheque() {
           return(this.numcheque);
    }

    public Signature getAuthentification() {
           return(this.signature);
    }

    
}

ConsultationImplementation.java  
-------------------------------------------------------------------------------
public class ConsultationImplementation implements _ConsultationOperations{
    
    //membres
    int type;
    IdentiteBancaire ib;
    
    //constructeur
    public ConsultationImplementation(int typec,IdentiteBancaire num){
        this.type=typec;
        this.ib=num;
    }
    
    public int getType() {
        return(this.type);
    }

    public IdentiteBancaire getIb() {
           return(this.ib);
    }
    
    
}

GestionnaireImplementation.java  
-------------------------------------------------------------------------------
import java.util.*;
import javax.swing.*;
import org.omg.CORBA.SystemException;
/**
 *
 */
public class GestionnaireImplementation implements _GestionnaireOperations {           
    //membres
    String libelle;
    Agence agence;
    String codguichet;
    String codinit;
    Hashtable liste_compte;
    
    //constructeur
    public GestionnaireImplementation(String numg,String lib,
                      Agence agenceg){
    this.agence=agenceg;
    this.libelle=lib;
    this.codguichet=numg;
    liste_compte = new Hashtable(); 
    this.codinit="00000";
        
    }
    
    /**ouvrir un compte
      *retourne le compte
      **/
    public CompteClient creerCompteClient(Client cli,String lib,float sold,
                                          String codlocal,
                                          float decouvertMaximum){
    System.out.println("banque : "+(this.getLibelle()));    
    
    Gestionnaire ge=new _tie_Gestionnaire(this);
    //creer le cpte client associe 
    /*calculer le code local
    
    String cod1=this.getCodeInit();
    System.out.println("code init: "+cod1);
    long  codloc1=parseLong((String)cod1);
    System.out.println("code init en entier "+codloc1);
    codloc1++;
    System.out.println("code init en entier "+codloc1);
    String codlocal=codloc1.toString();
    System.out.println("codelocal finish "+codlocal);
    */
    
    CompteClientImplementation cpt=null;
    try{
        //pr l'instant codelocal
        cpt=new CompteClientImplementation(cli,lib,sold,codlocal,
                                        ge,decouvertMaximum);
        System.out.println("cptimplementation ok");
    }
    catch (SystemException se){
        System.out.println("exception during CompteClientImplementation");
        System.out.println("Exception : "+se.toString());
    }
    System.out.println("CompteClient ?");
    CompteClient cptclient=new _tie_CompteClient(cpt);
    System.out.println("CompteClient ok");
    
    //aff gestionnaire
    Gestionnaire mongest=cpt.getGestionnaire();
    String n=mongest.getNumero();
    System.out.println("code guichet du gestionnaire gestCA: "+n);
    
    //afficher l'ib
    IdentiteBancaire ibd=cptclient.getIb();
    System.out.println("code guichet: "+ibd.getCodeGuichet());
    System.out.println("code local: "+ibd.getCodeLocal());
    System.out.println("identite bancaire: "
                        +(cptclient.getIb()).getCodeGuichet()
                        +(cptclient.getIb()).getCodeLocal());
    
    //affiche client
    String monlib=cptclient.getLibelle();
    System.out.println("libelle du cpte :"+lib);
    
    //liste des comptes
    System.out.println("liste des comptes : "+(this.liste_compte));
    
    //ident bancaire du compte
    System.out.println("identite bancaire: "+ibd.getCodeGuichet()
                    +ibd.getCodeLocal());
    
    //enrg ds la hashtable numcpte+cpte
    (this.liste_compte).put(cptclient.getIb(),cptclient);
    System.out.println("taille de liste_compte: "+(this.liste_compte).size());
    System.out.println("elnts de liste_compte =>"
                        +(this.liste_compte).toString());    
    return(cptclient);
    }
    
    
    
    //fermer un compte, effacer de la hashtable
    public void fermerCompte(IdentiteBancaire ib) {
        CompteClient c=(CompteClient)liste_compte.remove(ib);
        //!!!retourne le cpt associe a ib
    }

    public void migrerCompte(CompteClient cptcli,
                             Agence agence){ ;}

    public void creerCB(Client cli,CompteClient cptcli) {;}

    public void fermerCB() {;}


    public void executer(Operation op) {
        
        System.out.println("_________________________________________________________");
        
        CompteRendu info=null;
        
        //obtenir l'ib du cpte source
        IdentiteBancaire ibsource=op.getSource();
        System.out.println("codeguichet du source: "+ibsource.getCodeGuichet());
        //obtenir l'ib du cpte
        IdentiteBancaire ibdest=op.getDestination();
        System.out.println("codeguichet du dest: "+ibdest.getCodeGuichet());
        
        //effectuer l'op sur les cptes
        if (op.getCible()==0){
            CompteClient cpts=this.getCompte(ibsource);
            info=cpts.effectuer(op); //crediter le dest    
            JOptionPane.showMessageDialog(null,info.getLibelle());
            op.setCible(1);
        }
        if (op.getCible()==1){
            CompteClient cptd=this.getCompte(ibdest);
            info=cptd.effectuer(op); //debiter le dest
            JOptionPane.showMessageDialog(null,info.getLibelle());
            op.setCible(0);
        }
            
    }

        
    //obtenir un cpte a partir de son num de cpte
    public CompteClient getCompte(IdentiteBancaire ib){
        if (ib.getCodeGuichet()==this.codguichet){
            CompteClient cpt=(CompteClient)liste_compte.get(ib);
            return(cpt);
        }
        return(null);
    }
    
    public String getLibelle() {
        return(this.libelle);
    }

    public String getNumero() {
        return(this.codguichet);
    }

    public Agence getAgence() {
        return(this.agence);
    }
    
    public String getCodeInit(){
        return(this.codinit);
    }
    
    public void setCodeInit(String nvcodinit){
        this.codinit=nvcodinit;
    }
}

ClientImplementation.java  
-------------------------------------------------------------------------------
import java.util.*;

public class ClientImplementation implements _ClientOperations{

    //membres
    String nom;
    String prenom;
    
    //constructeur
    public ClientImplementation(String nomcli,String prenomcli){
        this.nom=nomcli;
        this.prenom=prenomcli;
    }
    
    public String getNom(){
        return(nom);
    }
    
    public String getPrenom(){
        return(prenom);
    }
}

IdentiteBancaireImplementation.java  
-------------------------------------------------------------------------------


public class IdentiteBancaireImplementation 
    implements _IdentiteBancaireOperations{

    //membres
    String CodeBanque;
    String CodeGuichet;
    String CodeLocal;
    
    //constructeur
    public IdentiteBancaireImplementation(String codeb,String codeg,
                                        String codel){
        this.CodeBanque=codeb;
        this.CodeGuichet=codeg;
        this.CodeLocal=codel;
    }
    public String getCodeBanque() {
        return(CodeBanque);
    }
    
    public String getCodeGuichet() {
           return(CodeGuichet);
    }

    public String getCodeLocal() {
        return(CodeLocal);
    }

}

SignatureImplementation.java  
-------------------------------------------------------------------------------
public class SignatureImplementation implements _SignatureOperations{
    String nom;
    
    public SignatureImplementation(String noms){
        this.nom=noms;
    }

    public String getNom(){
        return(nom);
    }
}

CentreCBImplementation.java  
-------------------------------------------------------------------------------
public class CentreCBImplementation implements _CentreCBOperations
{
    String nomCentreCB;
    
    public CentreCBImplementation(String nom){
        this.nomCentreCB=nom;
    }
}

AgenceImplementation.java  
-------------------------------------------------------------------------------
public class AgenceImplementation implements _AgenceOperations{

    //membres
    String nom;
    /**
     * gestionnaire (unique) de l'agence
     **/
    GestionnaireImplementation gestion;
    Gestionnaire gestionnaire;
    
    //constructeur
    public AgenceImplementation(String nomag){
        this.nom=nomag;
        gestion=new GestionnaireImplementation("","",(Agence)this);
        gestionnaire=new _tie_Gestionnaire(gestion);
    }

    public Gestionnaire getGestionnaire(){
        return(this.gestionnaire);
    }
    
    public String getNom(){
        return(this.nom);
    }
}

MaDateImplementation.java  
-------------------------------------------------------------------------------
import java.util.Date;

public class MaDateImplementation extends Date implements _MaDateOperations
{
    public MaDateImplementation(){
        super();
    }
    public MaDateImplementation(String d){
        super(d);
    }
    
    
    public String showDate(){
        String d=this.toString();
        return(d);
    }
    
    public boolean after(MaDate d){
        return(super.after((Date)d));
        
    }
    
}

ApplServeur.java  
-------------------------------------------------------------------------------
import IE.Iona.OrbixWeb._CORBA;
import IE.Iona.OrbixWeb.CORBA.ORB;
import org.omg.CORBA.SystemException;
import javax.swing.*;
/**
 * ApplServeur serveur des gestionnaires de comptes
 * du CréditAgricole et du CréditLyonnais.
 * */
public class ApplServeur
{
    public static void main(String args[]){
        
        /**
         * creation et initialisation de l'ORB
         * */
        ORB orb=(ORB)org.omg.CORBA.ORB.init();
            
        Gestionnaire gestCA=null;
        Gestionnaire gestCL=null;
                
        //creation des gestionnaires
        GestionnaireImplementation ga=new GestionnaireImplementation(
                                        "001","CréditAgricole",null);
        gestCA=new _tie_Gestionnaire(ga,"CA");
        System.out.println("gestCA cree => "+gestCA);
        
        GestionnaireImplementation gl=new GestionnaireImplementation(
                                        "002","CréditLyonnais",null);
        gestCL=new _tie_Gestionnaire(gl,"CL");
        System.out.println("gestCL cree => "+ gestCL);
        /**
         * gestCA et gestCL connectés à l'ORB
         */    
        orb.connect(gestCA);
        orb.connect(gestCL);
    
//        _CORBA.Orbix.impl_is_ready("BanqueServeur");
        System.out.println("serveur en attente");
        
        try {
                    System.out.println("pause");

                Thread.sleep(500000);
            } 
        catch(InterruptedException ex){}
        
        orb.disconnect(gestCA);
        orb.disconnect(gestCL);
        System.out.println("deconnexion");
    }
}

ApplClientDemo.java  
-------------------------------------------------------------------------------
import IE.Iona.OrbixWeb._CORBA;
import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.util.Date;
import java.awt.event.*;
import IE.Iona.OrbixWeb.CORBA.ORB;
import org.omg.CORBA.SystemException;

public class ApplClientDemo
{
    public static void main(String args[]){
            
    /**
     * initialisation de l'ORB.
     * */
    ORB.init();
        
    /**
     * référence à un gestionnaire du CréditAgricole: gca,
     * référence à un gestionnaire du CréditLyonnais: gcl.
     * */
    Gestionnaire gca=null;
    Gestionnaire gcl=null;
    
        
    /**gca et gcl liés avec le serveur ApplServeur, 
     * sur la machine mass-handicap.univ-tlse2.fr.
     * */
    try {
        gca=GestionnaireHelper.bind("CA:ApplServeur",
                                    "mass-handicap.univ-tlse2.fr");
        System.out.println("liaison avec gestCA ok");
        gcl=GestionnaireHelper.bind("CL:ApplServeur",
                                    "mass-handicap.univ-tlse2.fr");
        System.out.println("liaison avec gestCL ok");
    }
    catch (SystemException ex){
        JOptionPane.showMessageDialog(null,"BIND EN PANNE");
        System.out.println("exception during bind");
        System.out.println(ex.toString());
    }
    
        
    
    
    
    //_______________reation d un cpte c1 au credit agricole______________________
    
    //creation d un compte c1 au credit agricole
    JOptionPane.showMessageDialog(null,"vous êtes à la banque du "
                                       +gca.getLibelle());
    System.out.println("creation compte c1 au credit agricole");
    
    //saisie nom du client1
    String nomClient1 = JOptionPane.showInputDialog(null,
                                "A quel nom souhaitez-vous ouvrir un compte ?");
    System.out.println("nom du client: "+nomClient1);
    
    //creation du client1
    System.out.println("creation du client1");
    ClientImplementation cli1=new ClientImplementation(nomClient1,nomClient1);
    Client client1=new _tie_Client(cli1);
    System.out.println("client1 cree => "+client1);
    
    //codeguichet du gestionnaire gca
    String codeg1=gca.getNumero();
    System.out.println("code guichet gestCA : "+codeg1);
    
    //creer compte client1
    CompteClient c1=null;
    try {
        //001=codelocal
        c1= gca.creerCompteClient(client1,nomClient1,320,"001",300);
        System.out.println("compte c1 cree => "+c1);
        
    }
    catch (SystemException se) {
        System.out.println("exception in creerCompteClient");
        System.out.println(se.toString());
    }
    
    //affichage du solde du client1
    JOptionPane.showMessageDialog(null,
                                  "solde de "+c1.getLibelle()+" "
                                  +c1.getSolde());
                          

    
    
    
    //______________________retrait c1 de 400__________________________________
    
    OperationImplementation opr=null;
    //date du retrait=date du jour
    MaDateImplementation dar=new MaDateImplementation();
    MaDate currentDateRetrait=new _tie_MaDate(dar);
    try {
        //pr retrait cible=0
         opr=new OperationImplementation(0,c1.getIb(),700,"retrait",
                                        null,currentDateRetrait);
        }
    catch (SystemException se) {
        System.out.println("exception during OperationImplementation retrait");
        System.out.println("Exception : "+se.toString());
        }
    Operation retrait=new _tie_Operation(opr);
    //effectuer le retrait sur c1
    CompteRendu compterendu1=c1.effectuer(retrait);
    JOptionPane.showMessageDialog(null,compterendu1.getLibelle());
    
    
    
    //_______________________depot 56.50 sur c1_________________________________
    
    OperationImplementation opd=null;
    //date du retrait=date du jour
    MaDateImplementation dad=new MaDateImplementation();
    MaDate currentDateDepot=new _tie_MaDate(dad);
    try {
        //pr depot cible=1
         opd=new OperationImplementation(1,c1.getIb(),(float)56.5,"dépot",
                                        null,currentDateDepot);
        }
    catch (SystemException se) {
        System.out.println("exception during OperationImplementation depot");
        System.out.println("Exception : "+se.toString());
        }
    Operation depot=new _tie_Operation(opd);
    //effectuer le retrait sur c1
    CompteRendu compterendu2=c1.effectuer(depot);
    JOptionPane.showMessageDialog(null,compterendu2.getLibelle());
    
    
    
    
    //________________creation d un cpte c2 au credit lyonnais_________________    
    
    //creation d'un compte c2 au CL
    JOptionPane.showMessageDialog(null,"vous êtes à la banque du "
                                       +gcl.getLibelle());
    System.out.println("creation compte c2 au credit lyonnais");
    
    //saisie nom du client2
    String nomClient2 = JOptionPane.showInputDialog(null,
                            "A quel nom souhaitez-vous ouvrir un compte ?");
    System.out.println("nom du client2: "+nomClient2);
    
    //creation du client2
    System.out.println("creation du client2");
    ClientImplementation cli2=new ClientImplementation(nomClient2,nomClient2);
    Client client2=new _tie_Client(cli2);
    System.out.println("client2 cree => "+client2);
    
    //codeguichet du gestionnaire gcl
    String codeg2=gcl.getNumero();
    System.out.println("code guichet gestCL : "+codeg2);
    
    //creer compte client2
    CompteClient c2=null;
    try {
        //001=codelocal
        c2=gcl.creerCompteClient(client2,nomClient2,100,"001",150);
        System.out.println("compte c2 cree => "+c2);
        
    }
    catch (SystemException se) {
        System.out.println("exception in creerCompteClient");
        System.out.println(se.toString());
    }
    
    //affichage du solde
    JOptionPane.showMessageDialog(null,
                                  "solde de "+c2.getLibelle()+" "
                                  +c2.getSolde());
        
    
    

    
    //____________________________virement de 50 de c1 sur c2_________________________    
    
    //creer une operation
    OperationImplementation op=null;
    MaDateImplementation dav=new MaDateImplementation();
    MaDate currentDateVirement=new _tie_MaDate(dav);
    System.out.println(currentDateVirement.showDate());
    
    try {
         op=new OperationImplementation(0,c1.getIb(),c2.getIb(),50,"virement",
                                        null,currentDateVirement);
        }
    catch (SystemException se) {
        System.out.println("exception during OperationImplementation virement");
        System.out.println("Exception : "+se.toString());
    }
    Operation o=new _tie_Operation(op);
    
    System.out.println("Operation creee ok");
    
    //affichage montant de l operation
    System.out.println("montant de l operation : "+o.getMontant());
    
    //affichage infos sur ib de source + dest
    IdentiteBancaire idsource=o.getSource();
    IdentiteBancaire iddest=o.getDestination();
    
    System.out.println("ib de c1 : "+idsource);
    System.out.println("ib de c2 : "+iddest);
    System.out.println("code guichet de c2 : "+iddest.getCodeGuichet());
    System.out.println("code local de c2 : "+iddest.getCodeLocal());
    System.out.println("code guichet de c1 : "+idsource.getCodeGuichet());
    System.out.println("code local de c1 : "+idsource.getCodeLocal());
    
    //affichage cpte associe a idsource
    CompteClient compte=gca.getCompte(idsource);//pb si=null car id.cog=""
    System.out.println("libelle du compte source: "+compte.getLibelle());
    System.out.println("solde de c1: "+compte.getSolde());
    
    //effectuer l operation sur c1
    System.out.println("operation a effectuer sur c1");
    CompteRendu compterendu3=c1.effectuer(o);
    //sur compte c1(qu il soit src ou dest)
    JOptionPane.showMessageDialog(null,compterendu3.getLibelle());
    
    //effectuer l operation sur c2
    System.out.println("operation a effectuer sur c2");
    o.setCible(1);
    CompteRendu compterendu4=c2.effectuer(o);
    //gest gcl execute op sur cpte dest
    //JOptionPane.showMessageDialog(null,compterendu4.getLibelle());
        
    
    
    
    //___________________consultation releve c1________________________________    
    
    //creer une consultation
    ConsultationImplementation co2=null;
    try {
         co2=new ConsultationImplementation(2,c1.getIb());
         System.out.println("ConsultationImplementation releve ok");
    }
    catch (SystemException se) {
        System.out.println("exception during ConsultationImplementation");
        System.out.println("Exception : "+se.toString());
    }
    
    Consultation cons2=new _tie_Consultation(co2);
    
    System.out.println("consultation releve creee ok");
    
    //effectuer la consultation
    CompteRendu cptr2=c1.consulter(cons2);
    //afficher le releve
    String rel=cptr2.showReleve();
    JOptionPane.showMessageDialog(null,rel);
    /*JOptionPane.showMessageDialog(null,"solde de "+
                                       c1.getLibelle()+" : "
                                       +cptr2.getSolde()+" au "
                                       +(cptr2.getDate()).showDate());
    
    */
    //___________________consultation solde c1__________________________________    
    
    //creer une consultation
    ConsultationImplementation co=null;
    try {
         co=new ConsultationImplementation(1,c1.getIb());
         }
    catch (SystemException se) {
        System.out.println("exception during ConsultationImplementation");
        System.out.println("Exception : "+se.toString());
    }
    
    Consultation c=new _tie_Consultation(co);
    
    //effectuer la consultation
    CompteRendu cptr1=c1.consulter(c);
    
    JOptionPane.showMessageDialog(null,"solde de "
                                       +c1.getLibelle()+" "+
                                       cptr1.getSolde()+" au "+
                                       (cptr1.getDate().showDate()));
    
    
    
    
    //_____________________consultation solde c2________________________________    
    
    //creer une consultation
    ConsultationImplementation consul=null;
    try {
         consul=new ConsultationImplementation(1,c2.getIb());
         }
    catch (SystemException se) {
        System.out.println("exception during ConsultationImplementation");
        System.out.println("Exception : "+se.toString());
    }
    
    Consultation consult=new _tie_Consultation(consul);
    
    //effectuer la consultation
    CompteRendu cptrs=c2.consulter(consult);
    
    JOptionPane.showMessageDialog(null,"solde de "
                                       +c2.getLibelle()+" "+
                                       cptrs.getSolde()+" au "+
                                       (cptrs.getDate().showDate()));
    
    
    
    }//fin main()
    
    
    
}  //fin class ApplClient

ApplClient.java  
-------------------------------------------------------------------------------
import IE.Iona.OrbixWeb._CORBA;
import javax.swing.*;
import java.awt.*;
import java.util.*;

import java.util.Date;
import java.awt.event.*;
import IE.Iona.OrbixWeb.CORBA.ORB;
import org.omg.CORBA.SystemException;

public class ApplClient
{
    
    //références gca et gcl à un gestionnaire CA et CL
    Gestionnaire gca=null;
    Gestionnaire gcl=null;
    
    //objets de l interface graphique
    JFrame f;
    JTextField tnom,tprenom,tnumero,tmontant,tdest;
    JComboBox listbanque,listop;
    CheckboxGroup cbgop;
    Checkbox rboperation,rbconsultation;
    JButton bok,bannuler,bokop,bannulerop,bsaisieok,bsaisieannuler;
    
    EvenementInterface evnt=new EvenementInterface();
    EvenementOperation evntop=new EvenementOperation();
    EvenementSaisie evntsaisie=new EvenementSaisie();
    
    Gestionnaire gclient=null;
        
    //constructeur
    public ApplClient() {
        connection();
        drawInterface();
    }
    
    
    //____________________methode de connexion_________________________________
    public void connection() {
        //initialisation de l'ORB
        ORB.init();
        //gca et gcl liés avec le serveur ApplServeur, sur la machine 
        //mass-handicap
        try {
            gca=GestionnaireHelper.bind("CA:ApplServeur",
                                        "mass-handicap.univ-tlse2.fr");
            System.out.println("liaison avec gestCA ok");
            gcl=GestionnaireHelper.bind("CL:ApplServeur",
                                        "mass-handicap.univ-tlse2.fr");
            System.out.println("liaison avec gestCL ok");
            //JOptionPane.showMessageDialog(null,"BIND OK");
        }
        catch (SystemException ex){
            JOptionPane.showMessageDialog(null,"BIND EN PANNE");
            System.out.println("exception during bind");
            System.out.println(ex.toString());
        }
    }  //fin connection
    
    
    //________________dessiner l interface graphique___________________________
    public void drawInterface(){
        
        f=new JFrame("Ouverture d'un compte");
        JPanel p= new JPanel();
        p.setLayout(new GridLayout(4,2));
        //labels
        JLabel lbanque= new JLabel("Banque : ");
        JLabel lnom= new JLabel("Nom : ");
        JLabel lprenom= new JLabel("Prénom : ");
        //textfields
        tnom=new JTextField();
        tprenom=new JTextField();
        //listebox des banques
        listbanque=new JComboBox();
        listbanque.addItem("Crédit Agricole");
        listbanque.addItem("Crédit Lyonnais");
        //bouton ok  
        bok=new JButton("OK");
        bok.setActionCommand("ok");
        bok.addActionListener(evnt);
        //bouton annuler
        bannuler=new JButton("ANNULER");
        bannuler.setActionCommand("annuler");
        bannuler.addActionListener(evnt);
        
        p.add(lbanque);
        p.add(listbanque);
        p.add(lnom);
        p.add(tnom);
        p.add(lprenom);
        p.add(tprenom);
        p.add(bok);
        p.add(bannuler);
        
        f.setContentPane(p);
        f.pack();
        f.setVisible(true);
        
    } //fin drawInterface
    
    
    
    //__________dessiner l interface graphique pour le menu des operations_____
    public void drawOperation(){
        JFrame fop=new JFrame("Opérations bancaires");
        //panel ppal
        JPanel pop=new JPanel();
        pop.setLayout(new GridLayout(4,1));
        //ensemble de boutons radios
        cbgop=new CheckboxGroup();
        //choix 1 bouton operation
        rboperation=new Checkbox("Effectuer une opération",cbgop,false);
        
        //choix 2 bouton consultation
        rbconsultation=new Checkbox("Effectuer une consultation",cbgop,false);
        
        //boutons op ok et annuler
        bokop=new JButton("ok");
        bokop.setActionCommand("ok");
        bokop.addActionListener(evntop);
        bannulerop=new JButton("Annuler");
        bannulerop.setActionCommand("annuler");
        bannulerop.addActionListener(evntop);
        
        
        pop.add(rboperation);
        pop.add(rbconsultation);
        pop.add(bokop);
        pop.add(bannulerop);
        
        
        fop.setContentPane(pop);
        fop.pack();
        fop.setVisible(true);
        
        
    ;}  //fin drawOperation()
        
    
    
    //______dessiner l interface pour la saisie de l'operation_________________
    public void drawSaisieOperation(){
        
        JFrame fsaisieop=new JFrame("Nature de l'opération bancaire");
        //panel
        JPanel psaisie=new JPanel();
        psaisie.setLayout(new GridLayout(5,2));
        //labels
        JLabel lnumero=new JLabel("Numéro de compte : ");
        JLabel lnature=new JLabel("Nature de l'opération : ");
        JLabel lmontant=new JLabel("Montant de l'opération : ");
        JLabel ldest=new JLabel("Numéro du compte destinataire : ");
        //ldest.setVisible(false);
        //textfields
        tnumero=new JTextField(6);
        tmontant=new JTextField();
        tdest=new JTextField();
        tdest.setEditable(false);
        //tdest.setVisible(false);
         //listbox
        listop=new JComboBox();
        listop.addItem("Retrait");
        listop.addItem("Versement");
        listop.addItem("Virement");
        //boutons
        bsaisieok=new JButton("OK");
        bsaisieok.setActionCommand("ok");
        bsaisieok.addActionListener(evntsaisie);
        bsaisieannuler=new JButton("Annuler");
        bsaisieannuler.setActionCommand("annuler");
        bsaisieannuler.addActionListener(evntsaisie);
        
        psaisie.add(lnumero);
        psaisie.add(tnumero);
        psaisie.add(lnature);
        psaisie.add(listop);
        psaisie.add(ldest);
        psaisie.add(tdest);
        psaisie.add(lmontant);
        psaisie.add(tmontant);
        psaisie.add(bsaisieok);
        psaisie.add(bsaisieannuler);
            
        fsaisieop.setContentPane(psaisie);
        
        if (listop.getSelectedIndex()==2){
            
            tdest.setEditable(true);
            fsaisieop.validate();
        }
        fsaisieop.pack();
        fsaisieop.setVisible(true);
        
    
    }  //fin drawSaisieOperation()
        
    
    
    //____________creation du client___________________________________________
    
    public Client enregistrerClient(String n,String p){
        //creation du client
        ClientImplementation cli1=new ClientImplementation(n,p);
        Client client1=new _tie_Client(cli1);
        return(client1);
        
    }//fin enregistrerClient()
        
    
    //_____________________ouverture du compte_________________________________
    
    public Gestionnaire ouvrirCompte(Client cli){
        CompteClient c1=null;
        //si banque du credit agricole
        if (listbanque.getSelectedIndex()==0){
            try {
                c1= gca.creerCompteClient(cli,"compte ouvert",0,"001",300);
            }
            catch (SystemException se) {
                System.out.println("exception in creerCompteClient");
                System.out.println(se.toString());
            }
            
            return(gca);
        }//fin if
        
        //si banque du credit lyonnais
        if (listbanque.getSelectedIndex()==1){
            try {
                c1= gcl.creerCompteClient(cli,"compte ouvert",0,"001",300);
                }
            catch (SystemException se) {
                System.out.println("exception in creerCompteClient");
                System.out.println(se.toString());
                }
            //affichage du solde du client1
            JOptionPane.showMessageDialog(null,
                                          "solde de "+cli.getPrenom()+" "+
                                          cli.getNom()+" "
                                          +c1.getSolde()+" francs");
            return(gcl);
        }//fin if2
        return(null);
    }//fin ouvrir compte
    
    
    
    //_____________________faire une operation_________________________________ 
    
    public void faireOperation(Gestionnaire g_op){
        //dessiner l interface pour la saisie de l op
        drawSaisieOperation();
    }
    
    
    
    //_____________________faire une consultation______________________________
    
    public void faireConsultation(){;}
    
    
    //_______________________retrait___________________________________________
    
    public void faireRetrait(String id,String s,float f){
        //date du retrait=date du jour
        MaDateImplementation dar=new MaDateImplementation();
        MaDate currentDateRetrait=new _tie_MaDate(dar);
        //creation de l'operation
        OperationImplementation opr=null;
        try {
        //pr retrait cible=0
         opr=new OperationImplementation(0,c1.getIb(),f,"retrait",
                                        null,currentDateRetrait);
        }
        catch (SystemException se) {
            System.out.println("exception during OpImplementation retrait");
            System.out.println("Exception : "+se.toString());
        }
        Operation retrait=new _tie_Operation(opr);
        //effectuer le retrait sur c1
        CompteRendu compterendu1=c1.effectuer(retrait);
        JOptionPane.showMessageDialog(null,compterendu1.getLibelle());
    }//fin faireRetrait
    
    //__________________________________depot__________________________________
    
    public void faireDepot(String a,float b){;}
    
    
    
    //_______________MAIN()____________________________________________________
    
    public static void main(String args[]){
        ApplClient myapp = new ApplClient();
        
    }//fin main()
    


    //______________________classes pr gérer les evnts_________________________
    
     class EvenementInterface implements ActionListener
    {
        public void actionPerformed(ActionEvent e)
        {    
            //si ouverture compte ok
            if(e.getActionCommand().equals("ok"))
            {
                if((tnom.getText()==null)|(tprenom.getText()==null))
                    JOptionPane.showMessageDialog(null,
                                     "Vous n'avez pas rempli tous les champs"); 
                else {
                    String nclient=tnom.getText();
                    String pclient=tprenom.getText();
                    //creation du client avec les infos saisies
                    Client monclient=enregistrerClient(nclient,pclient);
                    JOptionPane.showMessageDialog(null,
                        "Bienvenue "+pclient+" "+nclient+" à la banque du "
                        +listbanque.getSelectedItem());
                    gclient=ouvrirCompte(monclient);
                    drawOperation();
                }//fin else
            }//fin if ouverture
            //annuler 
            if(e.getActionCommand().equals("annuler"))
            {System.exit(0);}
        }
            
        }  //fin class Evenement
     
     
    //_________________________________________________________________________ 
    
    class EvenementOperation implements ActionListener{
        public void actionPerformed(ActionEvent e){
            //si une operation  bancaire est ok
            if(e.getActionCommand().equals("ok")){
                if (rboperation.getState()){
                    faireOperation(gclient);
                    
                }
                if (rbconsultation.getState()){
                    faireConsultation();
                }
            }//fin if op
            //annuler 
            if(e.getActionCommand().equals("annuler"))
            {System.exit(0);}
        }
            
    }  //fin class EvenementOperation
     
     
     //________________________________________________________________________
    
    class EvenementSaisie implements ActionListener{
        public void actionPerformed(ActionEvent e){
            //si ouverture compte ok
            if(e.getActionCommand().equals("ok"))
            {
                String num=tnumero.getText();
                String mont=tmontant.getText();
                float somme=mont.floatValue();
                //!!!pb num=IdentiteBancaire!
                gclient.getCompte(num);
                //retrait
                if (listop.getSelectedIndex()==0){
                    faireRetrait(num,somme);
                }
                //depot
                if (listop.getSelectedIndex()==1){
                    faireDepot(num,somme);
                }
                //virement
                if (listop.getSelectedIndex()==2){
                    //faireRetrait(num,somme)
                    ;
                }
            }
            //annuler 
            if(e.getActionCommand().equals("annuler"))
            {System.exit(0);}
        }
            
        }  //fin class EvenementSaisie
    
}  //fin class ApplClient