RMI Java – Guide complet pour la communication distante

---

La communication distante entre des applications Java est un élément essentiel dans de nombreux systèmes distribués. Le Java Remote Method Invocation (RMI) est l’un des mécanismes les plus puissants pour permettre cette communication. Dans cet article, nous explorerons en détail ce qu’est RMI, comment il fonctionne, et comment l’utiliser pour développer des applications distribuées robustes en Java.

Qu’est-ce que RMI Java ?

RMI, ou Remote Method Invocation, est un mécanisme de communication inter-processus qui permet à un programme Java de faire appel à des méthodes d’objets distants, comme s’ils étaient des objets locaux. Cela signifie qu’un objet Java peut invoquer une méthode sur un autre objet Java fonctionnant dans une machine virtuelle Java (JVM) différente, voire sur une machine physique différente, comme s’il était présent localement.

Le fonctionnement de RMI repose sur la sérialisation des objets et la communication via TCP/IP. Il permet aux développeurs de créer des applications distribuées en Java sans avoir à gérer directement les détails de la communication réseau.

Comment fonctionne RMI ?

Le fonctionnement de RMI repose sur plusieurs composants clés :

Interfaces distantes

Les interfaces distantes définissent les méthodes qui peuvent être invoquées à distance. Ces interfaces doivent étendre java.rmi.Remote et chaque méthode doit déclarer throws RemoteException.

Implémentations distantes

Les implémentations distantes sont les classes qui fournissent les implémentations des interfaces distantes. Ces classes doivent étendre java.rmi.server.UnicastRemoteObject ou implémenter l’interface java.rmi.server.RemoteObject.

Registre RMI

Le registre RMI est un service de nommage qui permet aux clients de rechercher et d’obtenir des références vers des objets distants. Il fournit une sorte de service de répertoire où les objets distants sont enregistrés sous un nom.

Stub et Skeleton A

vant Java 5, RMI utilisait des stubs et des squelettes pour la communication entre les clients et les serveurs. Les stubs sont des proxies côté client qui représentent les objets distants, tandis que les squelettes sont des proxies côté serveur qui reçoivent les appels des clients et les transmettent aux objets distants.

Utilisation de RMI

Pour utiliser RMI, voici les étapes générales à suivre :

1. Définir les interfaces distantes qui décrivent les méthodes à appeler à distance.
2. Implémenter ces interfaces dans des classes qui étendent UnicastRemoteObject.
3. Créer un registre RMI et enregistrer les objets distants.
4. Les clients recherchent l’objet distant dans le registre et invoquent ses méthodes comme s’il s’agissait d’objets locaux.

Exemple pratique

Considérons un exemple simple où un serveur expose une interface distante pour effectuer des opérations mathématiques. Voici comment cela pourrait être implémenté en utilisant RMI :

// Interface distante
import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Calculatrice extends Remote {
    int addition(int a, int b) throws RemoteException;
    int soustraction(int a, int b) throws RemoteException;
}

// Implémentation distante
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class CalculatriceImpl extends UnicastRemoteObject implements Calculatrice {
    protected CalculatriceImpl() throws RemoteException {
        super();
    }

    public int addition(int a, int b) throws RemoteException {
        return a + b;
    }

    public int soustraction(int a, int b) throws RemoteException {
        return a - b;
    }
}

// Serveur RMI
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Serveur {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.createRegistry(1099);
            registry.rebind("calculatrice", new CalculatriceImpl());
            System.out.println("Serveur prêt");
        } catch (Exception e) {
            System.err.println("Erreur serveur : " + e.toString());
        }
    }
}

// Client RMI
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Client {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.getRegistry("localhost");
            Calculatrice calculatrice = (Calculatrice) registry.lookup("calculatrice");

            int resultat = calculatrice.addition(5, 3);
            System.out.println("Résultat : " + resultat);
        } catch (Exception e) {
            System.err.println("Erreur client : " + e.toString());
        }
    }
}

Stub

En programmation Java et plus spécifiquement dans le contexte de RMI, un stub est un proxy côté client qui représente un objet distant. Le stub intercepte les appels de méthode effectués par le client et les transmet au serveur distant via le réseau. Il est responsable de la sérialisation des paramètres et de la désérialisation des résultats, ainsi que de la gestion des communications réseau sous-jacentes.

Skeleton

Dans le contexte de RMI, un squelette (skeleton en anglais) est un proxy côté serveur qui reçoit les appels de méthode provenant des clients RMI. Le squelette récupère les paramètres de l’appel, les désérialise, invoque la méthode correspondante sur l’objet distant réel, sérialise le résultat et le renvoie au client. Avant Java 5, les squelettes étaient nécessaires pour la communication RMI, mais à partir de Java 5, ils sont générés automatiquement et ne nécessitent plus d’implémentation explicite.

Serialization

La sérialisation est le processus de conversion d’un objet Java en un flux d’octets pouvant être facilement transmis sur le réseau ou stocké dans un fichier. Dans le contexte de RMI, la sérialisation est utilisée pour convertir les paramètres des méthodes, ainsi que les résultats de ces méthodes, en une forme qui peut être envoyée sur le réseau entre les clients et les serveurs RMI. Java fournit un mécanisme de sérialisation intégré via les interfaces java.io.Serializable et java.io.Externalizable.

Registry

Le registre RMI est un service de nommage qui permet aux clients de rechercher et d’obtenir des références vers des objets distants. Les serveurs enregistrent leurs objets distants dans le registre sous un nom unique, et les clients peuvent ensuite utiliser ce nom pour récupérer une référence vers l’objet distant correspondant. Le registre RMI est généralement démarré sur le même hôte que le serveur RMI, mais il peut également être exécuté sur un hôte distant pour permettre l’accès à des objets distants situés sur différentes machines.

*Synthèse

Le Java Remote Method Invocation (RMI) est un outil puissant pour créer des applications distribuées en Java. En utilisant RMI, les développeurs peuvent facilement créer des systèmes distribués où les objets Java peuvent appeler des méthodes sur des objets distants de manière transparente. Bien qu’il existe d’autres alternatives pour la communication distante en Java, telles que les services web et les technologies de messagerie, RMI reste une option populaire en raison de sa simplicité et de son intégration native avec la plateforme Java.

En maîtrisant les concepts et les techniques présentés dans ce guide, vous serez bien équipé pour développer des applications distribuées robustes en Java en utilisant RMI.

---

Exemple pratique : Utilisation du Registre RMI

Supposons que vous avez un serveur RMI qui fournit un service de calcul simple. Voici comment vous pouvez utiliser le registre RMI pour enregistrer votre objet distant et permettre aux clients de l’utiliser :

Serveur RMI

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

public class ServeurCalcul implements ServiceCalcul {
    public ServeurCalcul() {}

    public int addition(int a, int b) throws RemoteException {
        return a + b;
    }

    public int soustraction(int a, int b) throws RemoteException {
        return a - b;
    }

    public static void main(String[] args) {
        try {
            ServeurCalcul serveur = new ServeurCalcul();
            ServiceCalcul stub = (ServiceCalcul) UnicastRemoteObject.exportObject(serveur, 0);

            Registry registry = LocateRegistry.getRegistry();
            registry.rebind("ServiceCalcul", stub);

            System.out.println("Serveur prêt");
        } catch (Exception e) {
            System.err.println("Erreur serveur : " + e.toString());
        }
    }
}

Client RMI

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

public class ClientCalcul {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.getRegistry();
            ServiceCalcul stub = (ServiceCalcul) registry.lookup("ServiceCalcul");

            int resultat = stub.addition(5, 3);
            System.out.println("Résultat : " + resultat);
        } catch (Exception e) {
            System.err.println("Erreur client : " + e.toString());
        }
    }
}

Dans cet exemple, le serveur RMI crée une instance de ServeurCalcul, exporte cette instance en tant qu’objet distant à l’aide de UnicastRemoteObject.exportObject(), puis enregistre cet objet dans le registre RMI sous le nom “ServiceCalcul” à l’aide de registry.rebind(). Le client RMI recherche ensuite cet objet dans le registre à l’aide de registry.lookup() et invoque ses méthodes à distance.

Communication bidirectionnelle avec RMI

Supposons que vous ayez besoin de créer une application RMI où le serveur peut également invoquer des méthodes sur le client. Voici un exemple simple de comment cela pourrait être implémenté :

Interface RMI

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

public interface ClientInterface extends Remote {
    void afficherMessage(String message) throws RemoteException;
}

Implémentation du client

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class ClientImpl extends UnicastRemoteObject implements ClientInterface {
    protected ClientImpl() throws RemoteException {
        super();
    }

    public void afficherMessage(String message) throws RemoteException {
        System.out.println("Message du serveur : " + message);
    }
}

Implémentation du serveur

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

public class Serveur {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.createRegistry(1099);

            ClientInterface client = new ClientImpl();
            registry.rebind("client", client);

            System.out.println("Serveur prêt");
        } catch (Exception e) {
            System.err.println("Erreur serveur : " + e.toString());
        }
    }
}

Dans cet exemple, le serveur enregistre une instance de ClientImpl dans le registre RMI sous le nom “client”. Le client peut ensuite rechercher cet objet dans le registre et invoquer sa méthode afficherMessage().

Système de messagerie instantanée avec RMI

Imaginons que nous voulons créer un système de messagerie instantanée utilisant RMI, où les utilisateurs peuvent s’envoyer des messages en temps réel. Voici comment cela pourrait être implémenté :

Interface RMI pour le service de messagerie

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

public interface ChatService extends Remote {
    void envoyerMessage(String utilisateur, String message) throws RemoteException;
    void rejoindreChat(String utilisateur, ClientInterface client) throws RemoteException;
    void quitterChat(String utilisateur) throws RemoteException;
}

Interface RMI pour le client

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

public interface ClientInterface extends Remote {
    void recevoirMessage(String utilisateur, String message) throws RemoteException;
}

Implémentation du service de messagerie

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Map;

public class ChatServiceImpl extends UnicastRemoteObject implements ChatService {
    private Map<String, ClientInterface> utilisateurs = new HashMap<>();

    protected ChatServiceImpl() throws RemoteException {
        super();
    }

    public void envoyerMessage(String utilisateur, String message) throws RemoteException {
        for (ClientInterface client : utilisateurs.values()) {
            client.recevoirMessage(utilisateur, message);
        }
    }

    public void rejoindreChat(String utilisateur, ClientInterface client) throws RemoteException {
        utilisateurs.put(utilisateur, client);
        envoyerMessage("Serveur", utilisateur + " a rejoint le chat.");
    }

    public void quitterChat(String utilisateur) throws RemoteException {
        utilisateurs.remove(utilisateur);
        envoyerMessage("Serveur", utilisateur + " a quitté le chat.");
    }
}

Implémentation du client

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.Scanner;

public class ClientImpl extends UnicastRemoteObject implements ClientInterface {
    private String nomUtilisateur;
    private ChatService service;

    protected ClientImpl(String nomUtilisateur, ChatService service) throws RemoteException {
        super();
        this.nomUtilisateur = nomUtilisateur;
        this.service = service;
        service.rejoindreChat(nomUtilisateur, this);
    }

    public void recevoirMessage(String utilisateur, String message) throws RemoteException {
        System.out.println(utilisateur + " : " + message);
    }

    public void envoyerMessage(String message) throws RemoteException {
        service.envoyerMessage(nomUtilisateur, message);
    }

    public static void main(String[] args) {
        try {
            String nomUtilisateur = args[0];
            ChatService service = (ChatService) java.rmi.Naming.lookup("rmi://localhost:1099/ChatService");
            ClientInterface client = new ClientImpl(nomUtilisateur, service);

            Scanner scanner = new Scanner(System.in);
            while (true) {
                String message = scanner.nextLine();
                client.envoyerMessage(message);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous avons un service de messagerie RMI qui permet aux clients de rejoindre un chat et d’envoyer des messages à tous les autres utilisateurs. Chaque client implémente l’interface ClientInterface pour recevoir des messages du serveur et envoyer des messages aux autres utilisateurs. Lorsqu’un client envoie un message, le serveur le diffuse à tous les autres clients connectés.

---

Annexe : Java RMI Server

Le serveur RMI en Java est une composante essentielle pour créer des applications distribuées qui utilisent le Java Remote Method Invocation (RMI). Cette annexe fournit une vue détaillée sur la mise en place d’un serveur RMI dans un environnement Java.

Étapes pour créer un serveur RMI :

1. Définition des interfaces distantes : Tout d’abord, vous devez définir les interfaces qui décrivent les méthodes que le serveur va fournir aux clients. Ces interfaces doivent étendre java.rmi.Remote et chaque méthode doit déclarer throws RemoteException.
2. Implémentation des interfaces distantes : Ensuite, implémentez ces interfaces dans des classes qui étendent java.rmi.server.UnicastRemoteObject. Ces classes sont les véritables objets distants que le serveur expose aux clients.
3. Création du registre RMI : Initialisez le registre RMI sur le serveur pour permettre aux clients de rechercher et d’obtenir des références vers les objets distants. Vous pouvez créer un registre en utilisant java.rmi.registry.LocateRegistry.createRegistry().
4. Enregistrement des objets distants : Une fois le registre créé, enregistrez les objets distants dans le registre sous un nom unique à l’aide de java.rmi.registry.Registry.rebind().
5. Démarrage du serveur : Exécutez le serveur et assurez-vous qu’il est en écoute pour accepter les connexions des clients.

Exemple de code pour un serveur RMI :

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

public class ServeurRMI {
    public static void main(String[] args) {
        try {
            // Créer un objet distant
            MonServiceDistant service = new MonServiceDistantImpl();

            // Exporter l'objet distant
            MonServiceDistant stub = (MonServiceDistant) UnicastRemoteObject.exportObject(service, 0);

            // Créer un registre RMI
            Registry registry = LocateRegistry.createRegistry(1099);

            // Enregistrer l'objet distant dans le registre sous un nom
            registry.rebind("MonServiceDistant", stub);

            System.out.println("Serveur RMI prêt !");
        } catch (Exception e) {
            System.err.println("Erreur serveur : " + e.toString());
            e.printStackTrace();
        }
    }
}

Dans cet exemple, un objet distant MonServiceDistant est créé et exporté en tant que stub à l’aide de UnicastRemoteObject.exportObject(). Ensuite, un registre RMI est créé sur le port 1099, et l’objet distant est enregistré dans le registre sous le nom “MonServiceDistant” à l’aide de Registry.rebind().

Conclusion :

La mise en place d’un serveur RMI en Java implique la définition d’interfaces distantes, l’implémentation d’objets distants, la création d’un registre RMI et l’enregistrement des objets distants dans ce registre. En suivant ces étapes et en utilisant les classes fournies par Java RMI, vous pouvez facilement créer des serveurs RMI robustes pour vos applications distribuées.

---

FAQ

1. Comment fonctionne RMI Java ?

RMI permet à Java d’appeler des méthodes sur des objets distants.

2. Qu’est-ce qu’un stub dans RMI Java ?

Un proxy côté client qui représente un objet distant.

3. Quel est le rôle d’un squelette dans RMI ?

Un proxy côté serveur qui reçoit les appels des clients.

4. Qu’est-ce que la sérialisation dans RMI ?

Conversion des objets en flux d’octets pour la communication réseau.

5. Qu’est-ce qu’un registre RMI ?

Service de nommage pour rechercher des objets distants.

6. Quelles sont les étapes pour utiliser RMI ?

Définir les interfaces, implémenter les objets distants, créer un registre.

7. RMI est-il toujours utilisé ?

Oui, surtout pour les applications internes basées sur Java.

8. Quelle est la différence avec les services web ?

RMI est spécifique à Java, tandis que les services web sont inter-plateformes.

9. Pourquoi utiliser RMI Java ?

Simplifie la communication entre objets Java distants.

10. Quels sont les avantages de RMI ?

Intégration native avec Java et gestion transparente des communications.