Tutoriel Java RMI

image_pdfimage_print

RMI signifie Remote Method Invocation. Il s’agit d’un mécanisme qui permet à un objet résidant dans un système (JVM) d’accéder à / invoquer un objet exécuté sur une autre JVM.

RMI est utilisé pour créer des applications distribuées, il fournit une communication à distance entre les programmes Java. Il est fourni dans le package java.rmi.
 
 

Architecture d’une application RMI

Dans une application RMI, nous écrivons deux programmes, un programme serveur (réside sur le serveur) et un programme client (réside sur le client).

À l’intérieur du programme serveur, un objet distant est créé et la référence de cet objet est mise à la disposition du client (à l’aide du registre).

Le programme client demande les objets distants sur le serveur et tente d’appeler ses méthodes.

L’image suivant montre l’architecture d’une application RMI.
 


 
Regardons maintenant les composants de cette architecture.

  • Stub : Un stub est une représentation (proxy) de l’objet distant chez le client. Il réside dans le système client; il agit comme une passerelle pour le programme client.
  • Skeleton : C’est l’objet qui réside du côté serveur. stub communique avec Skeleton pour transmettre la demande à l’objet distant.
  • RRL (Remote Reference Layer) : C’est la couche qui gère les références faites par le client à l’objet distant.
  • Couche de transport : Cette couche connecte le client et le serveur. Il gère la connexion existante et établit également de nouvelles connexions.

 

Fonctionnement d’une application RMI

Les points suivants résument le fonctionnement d’une application RMI :

  • Lorsque le client fait un appel à l’objet distant, il est reçu par le stub qui transmet finalement cette demande au RRL.
  • Lorsque le RRL côté client reçoit la demande, il invoque une méthode appelée invoke() de l’objet remoteRef. Il transmet la demande au RRL côté serveur.
  • Le RRL côté serveur transmet la demande au Skeleton (proxy sur le serveur) qui appelle finalement l’objet requis sur le serveur.
  • Le résultat est transmis au client.

 
 

Registre RMI

Le registre RMI est un espace de noms sur lequel tous les objets serveur sont placés. Chaque fois que le serveur crée un objet, il enregistre cet objet avec RMIregistry (en utilisant les méthodes bind() ou reBind()). Ceux-ci sont enregistrés en utilisant un nom unique appelé ‘bind name’.

Pour appeler un objet distant, le client a besoin d’une référence de cet objet. À ce moment, le client récupère l’objet à partir du Registre à l’aide de son nom ‘bind name’ (à l’aide de la méthode lookup()).

L’illustration suivante explique l’ensemble du processus
 


 

Objectifs du RMI
  • Pour minimiser la complexité de l’application.
  • Pour préserver la sécurité.
  • Garbage collection distribuée.
  • Travaille avec des objets distants.

 

Exemple d’une application Java RMI

Pour écrire une application Java RMI, vous devez suivre les étapes ci-dessous:

  • Étape 1: Définir l’interface de l’objet distant
  • Étape 2: Développer la classe qui implémente l’interface de l’objet distant
  • Étape 3: Développer le programme serveur
  • Étape 4: Développer le programme client
  • Étape 5: Compiler l’application
  • Étape 6: Exécutez l’application

 
 

Étape 1: Définir l’interface de l’objet distant

L’interface de l’objet distant fournit la description de toutes les méthodes d’un objet distant particulier. Le client communique avec cette interface distante.

Pour créer l’interface de l’objet distant :

  • Créez une interface qui hérite de l’interface prédéfinie Remote.
  • Déclarez toutes les méthodes métier pouvant être invoquées par le client dans cette interface.
  • Puisqu’il existe un risque de problèmes de réseau pendant les appels distants, une exception nommée RemoteException peut se produire.

Voici un exemple de l’interface de l’objet distant. Ici, nous avons défini une interface avec le nom Hello et elle a une méthode appelée showMsg().

import java.rmi.Remote; 
import java.rmi.RemoteException;  

// Créer l'interface de l'objet distant
public interface Hello extends Remote {  
   void showMsg() throws RemoteException;  
}

 

Étape 2: Développer la classe qui implémente l’interface de l’objet distant

Nous devons implémenter l’interface distante créée à l’étape 1. Pour créer la classe qui implémente l’interface de l’objet distant:

  • Implémentez l’interface créée à l’étape 1.
  • Fournit l’implémentation de toutes les méthodes abstraites de l’interface distante.

Voici la classe qui implémente l’interface de l’objet distant. Ici, nous avons créé une classe nommée ‘ImpClasse’ et implémenté l’interface Hello créée à l’étape précédente et fourni le corps de cette méthode qui affiche le message Hello World!.

// implémenter l'interface créée à l'étape 1
public class ImpClasse implements Hello {  
   
   // implémenter la méthode d'interface
   public void showMsg() {  
      System.out.println("Hello World!");  
   }  
}

 
 

Étape 3: Développer le programme Serveur

Le programme Serveur doit hériter la classe qui implémente l’interface de l’objet distant. Ici, nous devons créer un objet distant et le lier à RMIregistry.

Pour développer le programme Serveur:

  • Créez un objet distant en instanciant la classe qui implémente l’interface de l’objet distant.
  • Exportez l’objet distant à l’aide de la méthode exportObject() de la classe nommée UnicastRemoteObject qui appartient au package java.rmi.server.
  • Récupérez le registre RMI à l’aide de la méthode getRegistry() de la classe LocateRegistry qui appartient au package java.rmi.registry.
  • Liez l’objet distant créé au registre à l’aide de la méthode bind() de la classe nommée Registry. À cette méthode, passez une chaîne représentant le nom associé à cet objet(bind name) et l’objet exporté, en tant que paramètres.

Voici un exemple du programme Serveur:

import java.rmi.RemoteException; 
import java.rmi.registry.Registry; 
import java.rmi.registry.LocateRegistry; 
import java.rmi.server.UnicastRemoteObject; 

public class Server extends ImpClasse { 

   public Server() {} 
   
   public static void main(String args[]) { 
      try { 
         // crée l'objet distant
         ImpClasse obj = new ImpClasse(); 

         // ici, nous exportons l'objet distant vers le stub
         Hello stub = (Hello) UnicastRemoteObject.exportObject(obj, 0);  

         // Liaison de l'objet distant (stub) dans le Registre
         Registry reg = LocateRegistry.getRegistry(); 

         reg.bind("Hello", stub);  
         System.out.println("Le Serveur est prêt..."); 
      } catch (Exception e) { 
         System.err.println(e.toString()); 
         e.printStackTrace(); 
      } 
   } 
}

 

Étape 4: Développer le programme Client

Le programme client, récupère l’objet distant et appelle la méthode requise à l’aide de cet objet.

Pour développer un programme client:

  • Récupérez le registre RMI à l’aide de la méthode getRegistry() de la classe LocateRegistry qui appartient au package java.rmi.registry.
  • Récupérez l’objet dans le registre en utilisant la méthode lookup() de la classe Registry qui appartient au package java.rmi.registry. Pour cette méthode, vous devez passer une chaîne représentant le nom associé à cet objet(bind name) en tant que paramètre. Cela vous rendra l’objet distant.
  • lookup() renvoie un objet de type Remote, le transtypage vers le type Hello.
  • Enfin, appelez la méthode requise en utilisant l’objet distant obtenu.

Voici un exemple du programme Client:

import java.rmi.registry.LocateRegistry; 
import java.rmi.registry.Registry;  

public class Client { 

   private Client() {} 
   
   public static void main(String[] args) {  
      try {  
         // Récupérer le registre
         Registry reg = LocateRegistry.getRegistry(null); 
    
         // Recherche dans le registre de l'objet distant
         Hello stub = (Hello) reg.lookup("Hello"); 
    
         // Appel de la méthode distante à l'aide de l'objet obtenu
         stub.showMsg(); 
         
      } catch (Exception e) {
         System.err.println(e.toString()); 
         e.printStackTrace(); 
      } 
   } 
}

 
 

Étape 5: Compiler l’application

Pour compiler l’application :

  • Compilez l’interface de l’objet distant.
  • Compilez la classe qui implémente l’interface de l’objet distant.
  • Compilez le programme Serveur.
  • Compilez le programme Client.

Ou, Vous pouvez compilez tous les fichiers Java en une seule fois. comme indiqué ci-dessous.

> javac *.java


 

Étape 6: Exécutez l’application

Démarrez le registre rmi à l’aide de la commande suivante:

> start rmiregistry


 
Si vous affiche cette fenêtre cliquez sur « Autoriser l’accès ».


 
 
Exécutez le serveur comme indiqué ci-dessous.

> java Server


 
Exécutez le client comme indiqué ci-dessous.

> java Client


 
Dès que vous démarrez le client, vous verrez la sortie suivante sur le serveur.
 

 

Partagez cet article

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *