Java-RMI Remote Method Invocation

Architectures réparties
Java - RMI
Java
Java -- RMI
RMI
Remote
Remote Method
Method
Invocation
Invocation
Yann Viémont
Université de Versailles St-Quentin
Architectures réparties
Java - RMI
Plan
1. Introduction
2. Rappels sur les RPC
3. Le modèle objet de Java-RMI
4. Architecture générale
Architectures réparties
Java - RMI
1.
Introduction
= Disponible à partir de la version 1.1 du JDK de Sun (1995)
= Concurrent de CORBA et DCOM (.NET) pour offrir un
système d’objets distribués
= Conçu pour un environnement homogène de machines
virtuelles Java
ß Multiplateforme / Monolangage
= Sécurité et disponibilité (RMI Security Manager)
= Compatible avec le modèle objet de Java
ß Polymorphisme, instanceof, GC distribué, …
= Intégration des standards Internet
Architectures réparties
Java - RMI
Fonctionnalité
= Obtention de références sur les objets serveurs
= Invocation de méthode à distance
= Invocation sans compilation
= Importation / exportation / transmission dynamique d’objets
ß Par référence ou par copie
= Intégration au modèle objet de Java
= Préservation de l’intégrité des références
= Importation / exportation / transmission dynamique de
comportement (code)
= Cycle de vie des objets distants
ß Activation / Passivation / Persistance
Architectures réparties
Java - RMI
Objectifs
Le mécanisme doit permettre les opérations de base
suivantes :
= Obtenir une référence sur un objet distant
= Invoquer à distance une méthode sur cet objet
= Utiliser un objet d’un site distant comme un objet
local (importation d’une copie de l’objet)
= Importer dynamiquement une classe (type +
méthodes) avec les objets correspondants
= Exporter dynamiquement une classe (type +
méthodes) avec les objets correspondants
Architectures réparties
Java - RMI
Obtenir une référence
RMI comprend un serveur de nom (registry) basé sur les URL :
= Les méthodes de la classe Naming accèdent au registry
Du coté serveur, l’application invoque la méthode :
= Naming. bind (URL, objet)
Du coté client, l’application invoque la méthode :
= référence = Naming.lookup (URL)
L’objet reste sur le serveur
= Une instance de la souche (stub) est importée sur le
client
= La référence client désigne cette souche qui référence
l’objet distant
Architectures réparties
Java - RMI
Utiliser un objet distant
On peut utiliser localement un objet distant :
= De façon transparente
= Aussi simplement qu’un objet local
= résultat = objetLocal.méthode (objetDistant)
Architectures réparties
Java - RMI
Invoquer une méthode distante
Une méthode distante s’invoque de façon transparente :
= résultat = objetDistant.méthode (param1, …,
paramN)
Les paramètres d’entrée peuvent être :
= Des objets locaux transmis par copie et sérialisation
= Des objets distants (du serveur ou d’un site tiers)
dont la référence (objet + stub) est retransmise
Au retour :
= Les objets locaux modifiés sont recopiés
= Des références à de nouveaux objets distants
peuvent être obtenues
Architectures réparties
Java - RMI
Beaucoup plus qu’un simple RPC pour Java
Architectures réparties
Java - RMI
2. Rappels sur les RPC
Machine A
Client
Processus
uitilisateur
Machine B
Serveur
Requête
Invocation du service
(Processus veilleur)
Réseau
Exécution
du
service
(Processus serveur)
Réponse
renvoit des valeurs de retour
Architectures réparties
Java - RMI
Caractéristiques d’un RPC
Un APD, appel de procédure à distance (RPC, Remote
Procedure Call en anglais) permet :
= La transparence
ß Type de machine
ß Type de réseau
ß Localisation
ß Type de codage et standards
= Plusieurs sémantiques des appels
ß Synchrone / asynchrone
ß Au-moins-une-fois / au-plus-une-fois
Architectures réparties
Java - RMI
Processus serveur
Question : qui exécute la procédure distante ?
Réponse : un processus serveur autonome
= Un second processus est utilisé sur le serveur
Architectures réparties
Java - RMI
Problèmes
Les espaces d’adressage des processus client et serveur
sont disjoints
= Nouvelle pile, nouvelles variables
ß Une procédure appelée à distance forme un bloc
opaque pour les règles de visibilité
= Toutes les communications se font par passage de
paramètre
= On ne peut pas passer un pointeur
Les machines et / ou les systèmes sont différents
= Transformation des formats
= Interdiction des calculs explicites d’adresse
Architectures réparties
Java - RMI
Solutions
Solution 1 : les paramètres sont limités aux types de base
= Passage de paramètres par valeurs
= Sans pointeur, uniquement des tableaux
= Les structures et / ou listes doivent être
décomposées par le programmeur
Plusieurs standards ont été proposés
= Le plus utilisé est DXF (Data eXchange Format)
Solution 2 : sérialisation (languages objets)
= Les objets complexes sont transformés en un flot de
caractères selon un format d’échange
Architectures réparties
Java - RMI
Mécanisme d’appel compilé
= La procédure distante et le programme appelant
sont compilés séparément
= Le compilateur utilise une définition d’interface
abstraite
= L’appelant utilise le mécanisme d’appel habituel
= Une pseudo procédure se substitue localement à la
procédure distante
ß La souche client (stub)
= L’appelé utilise le mécanisme d’appel habituel
= Une pseudo procédure appelante se substitue à la
vraie sur la machine distante
ß La souche serveur (squeleton)
Architectures réparties
Java - RMI
Architecture
Client
Serveur
Procédure
appelante
Procédure
appelée
Appel de procédure
Souche client
Appel de procédure
Librairie APD
Appel système
Système et
communication
Appel de procédure
Souche serveur
Appel de procédure
Librairie et
runtime APD
Appel système
Système et
communication
Architectures réparties
Java - RMI
Définition d’interface
Une procédure distante n’est connue que par son
interface
= type_retour nom_procedure (mode_p1
type_p1, mode_p2 type_p2, …, mode_pn
type_pn) ;
= type_1 = … ;
= …
= type_m = … ;
L’interface est générée par le compilateur serveur
Elle est utilisée par le compilateur client
Architectures réparties
Java - RMI
3. Le modèle objet de Java-RMI
Le modèle objet distribué de RMI distingue deux types d’objets :
= Les objets distants (remote object)
= Les objets locaux
Un objet distant est connu des autres sites par une ou plusieurs
interfaces distantes (remote interfaces)
Chaque interface distante définit un ensemble de méthodes
invocables depuis les autres sites
Pour invoquer une méthode d’un objet distant :
= On connait son interface - son comportement
= On ne connait pas sa classe exacte - son implémentation
Architectures réparties
Java - RMI
Interfaces et classes en Java
Une interface définit un comportement abstrait
= Elle ne comporte pas de constructeur d’objets
= Elle définit la signature de méthodes abstraites
= Elle peut aussi définir des constantes
Une classe définit une implémentation particulière
= Elle comporte un constructeur d’objets
= Elle définit un type pour la structure des objets
= Elle spécifie des méthodes (signature + corps)
Une classe peut implémenter une ou plusieurs interfaces
= Elle doit alors fournir une implémentation des
méthodes correspondantes
Architectures réparties
Java - RMI
Exemple
InterfaceX
InterfaceY
méthodeX1 (…)
méthodeX2 (…)
…
IntX
IntY
ClasseA
méthodeX1 (…)
méthodeX2 (…)
…
méthodeY1 (…)
méthodeY2 (…)
…
méthodeA1 (…)
méthodeA2 (…)
…
InterfaceZ
méthodeY1 (…)
méthodeY2 (…)
…
méthodeZ1 (…)
méthodeZ2 (…)
…
IntX
IntZ
ClasseB
méthodeX1 (…)
méthodeX2 (…)
…
méthodeZ1 (…)
méthodeZ2 (…)
…
méthodeB1 (…)
méthodeB2 (…)
…
Architectures réparties
Java - RMI
Interfaces et héritage en Java
Un objet Java est créé comme une instance d’une classe
particulière
Java supporte trois mécanismes d’héritage
= simple : une classe peut étendre une autre classe
- sa superclasse = simple : une interface peut étendre une autre interface
- sa superinterface = multiple : une classe peut implémenter une ou plusieurs
interfaces
En résultat, un objet Java est aussi :
= Une instance de sa ou ses superclasses
= Une instance des toutes les interfaces implémentées par
sa classe et sa (ou ses) superclasse (s)
Architectures réparties
Java - RMI
Exemple
InterfaceX
méthodeX1 (…)
…
IntX
InterfaceW
InterfaceY
méthodeW1 (…)
…
méthodeY1 (…)
…
InterfaceZ
IntY
méthodeZ1 (…)
…
ClasseA
méthodeX1 (…)
…
méthodeY1 (…)
…
méthodeA1 (…)
…
implements
extends
IntZ
ClasseC
méthodeY2 (…)
…
méthodeW1 (…)
…
méthodeZ1 (…)
…
méthodeC1 (…)
méthodeC2 (…)
…
Architectures réparties
Java - RMI
Exemple (suite)
Les instructions suivantes sont toutes correctes :
ß ClasseC c1 = new ClasseC () ;
ß ClasseA a1 = new ClasseC () ;
ß ClasseA a2 = c1 ;
ß ClasseC c2 = (ClasseC) a2 ;
ß InterfaceX ix1 = new ClasseA () ;
ß InterfaceX ix2 = new ClasseC () ;
ß InterfaceZ iz1 = c1 ;
ß InterfaceZ iz2 = (ClasseC) a1 ;
L’ instruction suivante est incorrecte :
ß InterfaceZ iz3 = new ClasseA () ;
Architectures réparties
Java - RMI
Interfaces et classes de RMI
Interfaces
Classes
Exceptions
RemoteObject
IOException
RemoteServer
RemoteException
Remote
Serializable
UnicastRemoteObject
Architectures réparties
Java - RMI
L’interface Remote
Remote sert à identifier et référencer les objets distants
Remote ne définit aucune méthode
public interface Remote {}
Remote est la racine de toutes les interfaces distantes
définies par les utilisateurs pour manipuler les objets distants
public interface CompteBancaire
extends Remote
{
public void depot (float
montant)
throws
RemoteException ;
public void retrait (float
montant)
throws RemoteException ;
… }
Remote
CompteBancaire
Architectures réparties
Java - RMI
Objets distants de Java-RMI
Définition : un objet distant est une instance d’une classe
implémentant une ou plusieurs interfaces distantes.
Un objet non-distant est dit objet local.
NB : “distant” et “local” désignent la nature de l’objet et
non pas sa localisation sur un certain site.
Exemple pour l’accès aux objets depuis un site particulier
(Site local dans le tableau ci-dessous) selon la nature et la
localisation d’un objet :
Nature
des objets
Localisation des objets
Site local
Site distant
Objet
local
accès local
accès copie
locale
Objet
distant
accès local
accès distant
Architectures réparties
Java - RMI
La classe UnicastRemoteObject
La classe abstraite RemoteObject redéfinit plusieurs
méthodes de Object et en ajoute pour les objets distants
= hashCode, equals, toString
= getRef, toStub, writeObject, readObject
La classe abstraite RemoteServer définit des méthodes
communes à tous les serveurs
= unexportObject, getClientHost, …
La classe UnicastRemoteObject implémente les objets
distants non répliqués (mono-serveur)
= exportObject, …
Architectures réparties
Java - RMI
Conformité avec le modèle Java
Une référence à un objet distant peut être :
= Passée en paramètre de toute invocation de
méthode locale ou distante
= Retournée par toute invocation de méthode locale
ou distante
= Fondue en une référence sur des interfaces
distantes de son implémentation
= Utilisée en argument de instanceof pour tester les
interfaces supportées
Architectures réparties
Java - RMI
Spécificité du modèle RMI
Les clients des objets distants
= Ne voient que les interfaces distantes
= Ne voient jamais directement les classes qui les
implémentent
Les paramètres des méthodes distantes sont passés
= Par référence pour les objets distants
= par copie pour les autres objets
Architectures réparties
Java - RMI
Classes souches de Java-RMI
A chaque classe C d’objets distants sur le serveur est associée :
= Une classe souche CS (stub class)
= L’ensemble des interfaces I distantes de C
ß Implémentées directement par C
ß Ou implémentées par une superclasse de C
Pour un objet distant référencé depuis un site client :
= La classe souche est importée par le réseau
= Un objet de cette classe est créé localement
Le
Le système
système normal
normal de
de type
type de
de Java
Java fonctionne
fonctionne avec
avec les
les références
références
sur
sur les
les objets
objets souches
souches
Architectures réparties
Java - RMI
Exemple : hiérarchie de classe
Interfaces
Classes
Serializable
RemoteObject
Remote
RemoteInterfaceX
RemoteServer
RemoteInterfaceY
RemoteInterfaceZ
RemoteInterfaceW
UnicastRemoteObject
ClasseA
InterfaceM
ClasseB
InterfaceN
ClasseC
Architectures réparties
Java - RMI
Exemple : souches
Interfaces
Remote
Souches
RemoteInterfaceX
RemoteInterfaceY
RemoteInterfaceZ
RemoteInterfaceW
SoucheA
SoucheB
Architectures réparties
Java - RMI
Exemple : objets souches
Serveur
Client
RIX RIW
RIX RIW
ClasseA
SoucheA
SoucheA
RIX
RIZ
RIW
Importation
des
souches
IM
ClasseB
RIX
RIZ RIW
SoucheB
SoucheB
RIX
RIZ RIW
IM
IN
ClasseC
Création d’objets substituts
Obj_CAi
Obj_CBj
Obj_CCk
Obj_SAi
Obj_SBj
Obj_SCk
références distantes
Architectures réparties
Java - RMI
4. Architecture générale
RMI se décompose en trois couches :
Client
Serveur
Souches client
(Stubs)
Souches Serveur
(Skeletons)
Couche des références distantes
(Remote Reference Layer)
Couche Transport
Application
Mécanisme
RMI
Architectures réparties
Java - RMI
La couche des souches
La couche des souches :
= Constitue l’interface application / système RMI.
= Comporte les souches client (stubs) agissant
comme un objet par procuration (proxy)
= Comporte les souches serveur implémentant toutes
les interfaces de l!’objet distant.
= Soumet les données à la couche des références
distantes sous forme de flots de données entrants et
sortants - après sérialisation.
Architectures réparties
Java - RMI
Sérialisation
Définition : technique permettant la transmission des
données objets entre deux espaces d’adressage
différents
Les références à d’autres objets conduisent à une copie
en profondeur
Entrée :
= Organisé en graphe (connexe ou non)
Sortie :
= Un flot séquentiel de données
= Utilisant exclusivement un adressage relatif
Désérialisation
Sérialisation
= Un ensemble d’objets en mémoire (virtuelle)
Architectures réparties
Java - RMI
Les souches client (stubs)
La souche client :
= Initialise l!’appel vers un objet distant (via la couche
des références distantes )
= Sérialise les arguments sous forme d’un unique flot
de sortie
= Informe la couche des références distantes que
l!’appel peut être invoqué
= Désérialise le flot d’entrée contenant la valeur de
retour ou une exception
= Informe la couche des références distantes que
l!’appel est achevé
Architectures réparties
Java - RMI
Les souches serveur (squeletons)
La souche serveur :
= Reçoit l’appel par une méthode unique (aiguilleur)
= Désérialise le flot d’entrée des arguments
= Prépare l!’appel vers l’implémentation réelle de
l!’objet distant
= Distribue l’appel vers la bonne méthode cible
= Sérialise les valeurs de retour ou les exceptions
dans le flot de sortie
Architectures réparties
Java - RMI
La couche des références
distantes
Plusieurs protocoles d!’invocation possibles :
= Invocation point à point (Unicast)
= Invocation vers des groupes de réplication (Multicast)
Stratégie de reconnexion (si un objet devient inaccessible)
Deux composantes coopérantes :
= la composante coté client (client-side)
= la composante coté server (server-side)
Transmission de données entre couches transport par une
connexion orientée flux
Architectures réparties
Java - RMI
La couche transport
La couche transport de Java-RMI effectue :
= Mise en place, gestion, surveillance de la connexion
= Ecoute des appels arrivant
= Maintien d’une table d’objets distants pour l’espace
d’adressage
= Localisation du dispatcher pour la cible d’un appel
distant et transmission de la connexion
Architectures réparties
Java - RMI
Concepts de la couche transport
4 abstractions :
= Un endpoint indique l!’@ machine virtuelle Java.
= Un channel “conduit” entre 2@.
= Une connexion permet le transfert des données.
= Le transport effectue la gestion des channels.
Architectures réparties
Java - RMI
Nettoyage des objets distants
Ramasse-miette
Ramasse-miette (Garbage Collector) distribué
Invoqué quand :
= Les objets distants ne sont plus appelés (compteur
ref_counting == 0)
= Il n’y a plus ni référence locale ni référence distante
sur les objets locaux ou distants
Remarque :
=
Le GC ne garantit pas l’intégrité des références, il
peut rester une référence sans objet correspondant (
fi RemoteException)
Architectures réparties
Java - RMI
Chargement dynamique des
classes
Pendant l’exécution :
Chargement dynamique des classes nécessaires à
l’invocation des méthodes de l’objet distant.
= Classes stub et squelette (~proxies)
= Classes indirectement utilisées par RMI
Chargement dynamique des classes pour les copies des
objets locaux hors-site
= Classes et interfaces des objets hors-site
Architectures réparties
Java - RMI
Différents chargeurs de classe
= LocalClassLoader (selon le Classpath)
ß Chargement des classes connues localement
= AppletClassLoader
ß Chargement de l!’applet
ß Chargement des classes dépendantes sur le réseau
= RMIClassLoader
ß Vérifie que l’on ne peut pas charger avec le Classpath.
ß Localise la classe grâce à l’URL dans le flot (objet
distant).
ß Localise la classe grâce à l!’URL spécifié par
java.rmi.server.Codebase local (souche/squelette).
Architectures réparties
Java - RMI
Sécurité
Chargement local de classe :
= Pas de problème de sécurité
Chargement à partir du réseau :
= Nécessité d’un Security Manager.
ß Applet Security Manager (à lancer en 1er dans
une application).
ß RMI Security Manager (par défaut).
Architectures réparties
Java - RMI
Sécurité
Applet Security :
= Le chargement doit être fait sur applet (travail des
développeurs).
RMI Security :
= Lorsque non local (ex : bootstrapping).
= Toutes les classes téléchargées par le
RMIClassLoader.
= Pb : on ne peut pas prévenir le chargement de
classes abusant de ressource.
Architectures réparties
Java - RMI
Scénarios
Serveurs en mode ouvert ou fermé.
Application Java utilisant RMI :
ß Mode Client / Serveur
ß Mode Serveur / Client (callback)
ß Mode égal à égal (peer to peer)
Architectures réparties
Mode ouvert ou fermé
Serveur fermé :
= Pas de chargement de classe
= Interfaces locales au serveur
= Pas de Security Manager
Serveur ouvert :
= Chargement de classes avec l!’URL du
java.rmi.server.Codebase
= Contrôle par le RMI Security Manager
Java - RMI
Architectures réparties
Java - RMI
Applets
Classes fournies par serveur HTTP ou FTP
(URL page HTML)
Pas de chargement de classes si elles existent déjà sur le
serveur.
Architectures réparties
Java - RMI
Application Java distribuée
NB :
≠ Applet
Un seul serveur HTTP pour toutes les applications
distribuées sur le réseau
Chargement local d!’une application :
= Chargement des interfaces distantes
= Chargement des classes souche et squelette.
Chargement réseau (bootstrapping) :
= Toutes les classes peuvent être chargées à partir de
la même source réseau
Architectures réparties
Java - RMI
RMI à travers les Firewalls
Problème :
= Ouvrir un socket en présence de parefeux (Firewalls)
sur Intranet
Solution :
= Encapsulation d!’un appel RMI par le protocole HTTP
ß Appel RMI envoyé dans le corps d!’une requête
HTTP POST.
ß Retour dans une requête HTTP response.
Architectures réparties
Java - RMI
L’usine à sockets
Le factory de sockets :
= java.rmi.server.RMISocketFactory
= Fournisseur de ressource pour les sockets
= Création de socket permettant le tunneling
ß Socket client : connexion HTTP vers les hôtes
ß Socket serveur : si HTTP POST alors réponse
HTTP
Architectures réparties
Java - RMI
Configuration
Configuration du client : RAS
Configuration du serveur :
= La totalité du nom de l!’hôte serveur doit être incluse
dans les références distantes
= Si le serveur ne supporte pas les clients RMI en
dehors du parefeux :
ß Utilisation d’un serveur HTTP à l’écoute sur le
port 80.
ß Utilisation d!’un script CGI : /cgi-bin/java-rmi
Architectures réparties
Java - RMI
Multithreading
NAME
ADDRESS
Client
NAME
ADDRESS
NAME
ADDRESS
RMI
Client
Client
RMI
RMI
Server
JDBC
Expense
records
Architectures réparties
Java - RMI
Comparaison RMI / RPC
Orientation Objet
= Passage d!’objets complexes en paramètre.
= Création d!’objets à distance.
Séparation interface / implémentation
Client
Architectures réparties
Server
Java - RMI
Architecture d’objets distribués
Répartition des objets sur une architecture C/S ou 3 tiers
de façon libre.
Utilisation d’un Security Manager standard ou spécialisé.
Portable sur toute machine (VM).
Ramasse-miette distribué.
Multithreaded.
Architectures réparties
Java - RMI
Intégration intranet / extranet
Appel à distance / téléchargement de code
Encapsulation code non-Java avec JNI
Encapsulation BD avec JDBC
Récupère les avantages d!’un BUS Java :
= Puissance
= Sécurité
= Portabilité
Architectures réparties
Java - RMI
Implémentation des souches
L’implémentation des souches s’appuie sur les possibilités
objets de Java
Architectures réparties
Java - RMI
Classes et Interfaces des
souches
Classe ‘RemoteStub’
= Superclasse pour tous les stubs
Interface ‘RemoteCall’
= Gestion du transport des informations (flux)
Interface ‘RemoteRef’
= Attache locale à un objet distant
Interface ‘Skeleton’
= Répartiteur d’appels
Architectures réparties
Java - RMI
JINI
Architecture destinée à la gestion de périphériques en
réseau
= Utilise RMI
= Télécharge des données et du code pour piloter le
périphérique
= Constitue une première application de Service Web
Architectures réparties
Java - RMI
Fonctionnnement de JINI
Lors de l’ajout d’un périphérique:
Celui-ci se déclare auprès du serveur
‘Lookup Service’ puis lui envoie son pilote
Le client voulant utiliser le pilote envoie
une demande au serveur
Le serveur lui envoie le pilote du
périphérique