1 / 44

Objets distribués

Objets distribués. RMI Remote Method Invocation. Un objet distribué doit pouvoir être vu comme un objet « normal ». Soit la déclaration suivante : ObjetDistribue monObjetDistribue;

lieu
Download Presentation

Objets distribués

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Objets distribués

  2. RMIRemote Method Invocation

  3. Un objet distribué doit pouvoir être vu comme un objet « normal ». Soit la déclaration suivante : ObjetDistribue monObjetDistribue; . On doit pouvoir invoquer une méthode de cet objet situé sur une autre machine de la même façon qu’un objet local : monObjetDisribue.uneMethodeDeLOD();

  4. . On doit pouvoir utiliser cet objet distribué sans connaître sa localisation. On utilise pour cela un service sorte d’annuaire, qui doit nous renvoyer son adresse. monObjetDistribue= ServiceDeNoms.recherche(‘myDistributedObject’); . On doit pouvoir utiliser un objet distribué comme paramètre d’une méthode locale ou distante. x=monObjetLocal.uneMethodeDeLOL(monObjetDistribue); x=monObjetDistribue.uneMethodeDeLOD(autreObjetDistribue);

  5. . On doit pouvoir récupérer le résultat d’un appel de méthode sous la forme d’un objet distribué.

  6. RMI: permet la communication entre machines virtuelles Java (JVM) qui peuvent se trouver physiquement sur la même machine ou sur deux machines distinctes ( espace d’adressage différents) . Un but primaire pour les concepteurs de RMI était de permettre à des programmeurs de développer des programmes distribués de Java avec la mêmes syntaxe et sémantique utilisées pour des programmes non-distribués

  7. Présentation RMI est un système d’objets distribués constitué uniquement d’objets java ; . RMI est une Application Programming Interface (intégrée au JDK 1.1 et plus) ; . Développé par JavaSoft ;

  8. Objectifs • Rendre transparent l’accès à des objets distribués sur un réseau • Faciliter la mise en œuvre et l’utilisation d’objets distants Java • Préserver la sécurité (inhérent à l’environnement Java) • RMISecurityManager • Distributed Garbage Collector (DGC)

  9. . Mécanisme qui permet l’appel de méthodes entre objets Java qui s’exécutent éventuellement sur des JVM distinctes ; . L ‘appel peut se faire sur la même machine ou bien sur des machines connectées sur un réseau ; . Utilise les sockets ; . Les échanges respectent un protocole propriétaire : Remote Method Protocol ; . RMI repose sur les classes de sérialisation.

  10. Une référence à un OD peut être passée en • argument ou retournée en résultat d’un • appel dans toutes les invocations (locales ou • distantes) • Un OD peut être transformé (cast) en • n’importe quelles interfaces distantes • supportées par l’implémentation de l’objet

  11. Les clients (objets clients) des OD (objets • serveurs) interagissent avec des interfaces • distantes, • Les arguments locaux et les résultats d’une • invocation distante sont toujours passés par • copie et non par référence • leurs classes doivent implémentées • java.io.Serializable (sérialisation d ’objets)

  12. Le passage de paramètres • Pour résumer : • l’argument ou la valeur de retour d’une méthode • distante peut être de n’importe quel type Java y • compris les types simples, les objets locaux ou • les objets distants. • Si jamais le type n’est pas disponible • localement, il est chargé dynamiquement • (RMIClassLoader)

  13. Le passage de paramètres pour les paramètres locaux (objets ou types primitifs), le transfert se fait nécessairement par copie. S’il s’agit d’un objet, l’ensemble de ses variables est copié par sérialisation — il doit donc implémenter java.io.Serializable pour les paramètres qui seraient déjà des références d’OD, l’objet amorce (Stub) est passé — impossible de passer en paramètre un objet uniquement visible par les classes serveurs

  14. La notion d’interface L’interface constitue le contrat - abstrait -liant objets serveurs et objets clients nelle est destinée à être implémentée par l’OD et constitue la base d’appel pour les objets clients — elle définie les signatures (noms, types de retours, paramètres) d’un ensemble de méthodes et seules ces méthodes seront accessibles par un objet client

  15. La notion d’interface Pour RMI, c’est une interface Java traditionnelle … mais dérivant de la classe java.rmi.Remote

  16. L’exception RemoteException • Les objets clients doivent traiter des exceptions supplémentaires comme • RemoteException • Toute invocation distante de méthode doit • lever ou traiter cette exception • Peut se produire si la connexion a été • interrompue ou si le serveur distant ne peut • être trouvé

  17. Architecture Application Présentation Session Transport/ Réseau Liaison de données /Physique Invocation de la méthode distante Objet distant Stub Squelette Couche références distantes Couche références distantes TCP/IP TCP/IP

  18. Client Objet Appel local interface Appel distant méthode+ arguments Objet Client interface stub skeleton interface retour + exception Réseau

  19. Stub/ Skeleton Les amorces (Stub/Skeleton) . Elles assurent le rôle d’adaptateurs pour le transport des appels distants . Elles réalisent les appels sur la couche réseau . Elles réalisent l’assemblage et le désassemblage des paramètres (marshalling, unmarshalling) . Les amorces sont créées par le générateur rmic.

  20. Les Stubs . Représentants locaux de l’objet distribué ; . Initient une connexion avec la JVM distante en transmettant l’invocation distante à la couche des références d’objets ; . Assemblent les paramètres pour leur transfert à la JVM distante ; . Attendent les résultats de l’invocation distante ; . Désassemblent la valeur ou l’exception renvoyée ; . Renvoient la valeur à l’appelant ;

  21. Les Stubs • S’appuient sur la sérialisation. • il les transforme en un flot de données (flux de • pliage) transmissible sur le réseau • les objets doivent implémenter l’interface • java.io.Serializable ou • java.io.Externalizable

  22. Les squelettes . Désassemblent les paramètres pour la méthode distante ; . Font appel à la méthode demandée ; . Assemblage du résultat (valeur renvoyée ou exception) à destination de l.appelant.

  23. La couche des références d’objetsRemote Reference Layer . Permet d’obtenir une référence d’objet distribué à partir de la référence locale au stub ; . Cette fonction est assurée grâce à un service de noms rmiregister (qui possède une table de hachage dont les clés sont des noms et les valeurs sont des objets distants) ; . Un unique rmiregister par JVM ; . rmiregister s’exécute sur chaque machine hébergeant des objets distants ; rmiregister accepte des demandes de service sur le port 1099 par défaut;

  24. La couche transport • . Réalise les connexions réseau basées sur les flux entre les JVM • .emploie un protocole de communication propriétaire (JRMP:Java Remote Method Invocation) basé sur TCP/IP •  • Connecte les 2 espaces d’adressage (JVM) • Suit les connexions en cours • Ecoute et répond aux invocations • Construit une table des OD disponibles • Réalise l’aiguillage des invocations

  25. Développer une application avec RMI : Mise en œuvre 1. Définir une interface distante (Xyy.java) ; 2. Créer une classe implémentant cette interface (XyyImpl.java) ; 3. Compiler cette classe (javac XyyImpl.java) ; 4. Créer une application serveur (XyyServer.java) ; 5. Compiler l’application serveur ; 6. Créer les classes stub et skeleton à l’aide de rmic XyyImpl_Stub.java et XyyImpl_Skel.java; 7. Démarrage du registre avec rmiregistry ; 8. Lancer le serveur pour la création d’objets et leur enregistrement dans rmiregistry; 9. Créer une classe cliente qui appelle des méthodes distantes de l’objet distribué (XyyClient.java) ; 10. Compiler cette classe et la lancer.

  26. Example The first step is to write and compile the Java code for the service interface. The Calculator interface defines all of the remote features offered by the service: public interface Calculator extends java.rmi.Remote { public long add(long a, long b) throws java.rmi.RemoteException; public long sub(long a, long b) throws java.rmi.RemoteException; public long mul(long a, long b) throws java.rmi.RemoteException; public long div(long a, long b) throws java.rmi.RemoteException; }

  27. Notice this interface extends Remote, and each method signature declares that it may throw a RemoteException object. Copy this file to your directory and compile it with the Java compiler: >javac Calculator.java

  28. Implementation Next, you write the implementation for the remote service. This is the CalculatorImpl class: public class CalculatorImpl extends java.rmi.server.UnicastRemoteObject implements Calculator { // Implementations must have an explicit constructor // in order to declare the RemoteException exception public CalculatorImpl() throws java.rmi.RemoteException { super(); } public long add(long a, long b) throws java.rmi.RemoteException { return a + b; }

  29. public long sub(long a, long b) throws java.rmi.RemoteException { return a - b; } public long mul(long a, long b) throws java.rmi.RemoteException { return a * b; } public long div(long a, long b) throws java.rmi.RemoteException { return a / b; } }

  30. Stubs and Skeletons You next use the RMI compiler, rmic, to generate the stub and skeleton files. The compiler runs on the remote service implementation class file. >rmic CalculatorImpl Try this in your directory. After you run rmic you should find the file Calculator_Stub.class and, if you are running the Java 2 SDK, Calculator_Skel.class.

  31. Host Server import java.rmi.Naming; public class CalculatorServer { public CalculatorServer() { try { Calculator c = new CalculatorImpl(); Naming.rebind("rmi://localhost:1099/CalculatorService", c); } catch (Exception e) { System.out.println("Trouble: " + e); } } public static void main(String args[]) { new CalculatorServer(); } }

  32. Le client import java.rmi.Naming; import java.rmi.RemoteException; import java.net.*; import java.rmi.NotBoundException; public class CalculatorClient { public static void main(String[] args) { try { Calculator c = (Calculator) Naming.lookup( "rmi://localhost /CalculatorService"); System.out.println( c.sub(4, 3) ); System.out.println( c.add(4, 5) ); System.out.println( c.mul(3, 6) ); System.out.println( c.div(9, 3) ); … …

  33. Un autre exemple • Un « echo » distribué : • invocation distante de la méthode echo() d’un • objet distribué avec le mécanisme RMI. • — 4 programmes sont nécessaires : • g Echo : l’interface décrivant l’objet distant (OD) • g EchoImpl : l’implémentation de l’OD • g EchoAppliServer : une application serveur RMI • g EchoClient : l’application cliente utilisant l’OD

  34. 1) définir l’interface pour la classe distante nRappel : les classes placées à distance sont spécifiées par des interfaces qui doivent dériver de java.rmi.Remote et dont les méthodes lèvent une java.rmi.RemoteException package demo.rmi; import java.rmi.*; public interface Echo extends Remote { public String echo(String str) throws RemoteException; }

  35. 2) définir l’implémentation de l’OD package demo.rmi; import java.rmi.*; import java.rmi.server.*; public class EchoImpl extends UnicastRemoteObject implements Echo { public EchoImpl() throws RemoteException {super();} public String echo(String str) throws RemoteException { return "Echo : " + str; } }

  36. 3) définir une application serveur C’est le programme qui sera à l’écoute des demandes des clients. nil lui faut un SecurityManager spécifique : RMISecurityManager npour rendre l’objet disponible, il faut l’enregistrer dans le « RMIregistry » par la méthode statique : — Naming.rebind("echo", od);

  37. 3) définir une application serveur(suite) nPar la suite, cet objet distant sera accessible par les autres machines en indiquant son nom et la machine sur laquelle est exécuté ce serveur par String url = "rmi://nomServeurRMI:port/nomOD" String url = "rmi://patate.univ-tours.fr/echo » nCet " url RMI " sera utilisé par les clients pour interroger le serveur grâce à l’appel : Naming.lookup(url);

  38. 3) définir une application serveur(suite) package demo.rmi; public class EchoAppliServer { public static void main(String args[]) { // Création et installation du manager de sécurité System.setSecurityManager(new RMISecurityManager()); try {// Création de l’OD EchoImpl od = new EchoImpl(); // Enregistrement de l’OD dans RMI Naming.rebind("echo", od); } catch(Exception e) {…} }}

  39. Compiler les classes > javac -d $HOME/classes Echo.java > javac -d $HOME/classes EchoImpl.java > javac -d $HOME/classes EchoAppliServer.java Ces commandes créent les fichiers .class correspondants et les déposent dans $HOME/classes/demo/rmi/

  40. 4) créer les amorces Il s’agit d’invoquer le compilateur d’amorces rmic sur la classe compilée de l’OD : > rmic -d $HOME/classes demo.rmi.EchoImpl n2 classes sont alors créees représentant la souche (ou Stub) et le Skeleton : EchoImpl_Stub.class EchoImpl_Skel.class

  41. 5) Lancer rmiregister etl’application serveur nIl faut d ’abord lancer le rmiregister puis le serveur : > rmiregister& > java demo.rmi.EchoAppliServer nCe qui rend maintenant le serveur disponible pour de futurs clients ...

  42. 6) définir l’application clienteutilisant l’OD package demo.rmi; import java.rmi.*; import java.rmi.registery.*; public class EchoClient { public static void main(String args[]) { // Création et installation du manager de sécurité System.setSecurityManager(new RMISecurityManager()); // Recherche de l’OD String url = "rmi://" + args[0] + "/echo"; Echo od = (Echo)Naming.lookup(url); System.out.println(od.echo(args[1])); } }

  43. 6) définir l’application clienteutilisant l’OD(suite) Remarque : nce code manipule l’OD comme s’il était local. nAprès avoir installé un RMISecurityManager, le client recherche l’objet distant en interrogeant le service « d’annuaire » RMI par : — Naming.lookup(url) ou url est un « url RMI » de la forme : gString url="rmi://nomServeurRMI:port/nomOD" — si une seule machine : nomServeurRMI= " localhost  "

  44. 6) compiler et lancer l’applicationcliente % javac -d $HOME/classes EchoClient.java % java demo.rmi.EchoClient patate.univ-tours.fr coucou % Echo : coucou

More Related