TP Java RMI

Frank Singhoff

SOMMAIRE

·        I. Exemple de programme

o        I.1 L'application

o        I.2 Questions

·        II. Utilisation élémentaire

·        III. Usine à objets

·        IV. Objets sérialisables

·        V. Exercice de synthèse

·        VI. Corrections

I. Exemple de programme

I.1 L'application

Récupérez les fichiers de ce premier exercice à partir de ce répertoire . Sauvez tous ces fichiers dans un répertoire EXO1. Nous allons regarder les trois fichiers source suivant :

Hello.java     HelloServeur.java   HelloClient.java    

Environnement Java :
Avant de faire ce TP, exécutez un des scripts rmi.bash Cette opération doit être effectuée avant de lancer javac, java, rmiregistry.

Par exemple, pour utiliser ce script, taper :


source rmi.bash




On commente ici le contenu de Hello.java, l'interface :

public interface Hello extends java.rmi.Remote

{

    String lireMessage(int num) throws java.rmi.RemoteException;

}

Remote signifie que la méthode lireMessage de cette classe Hello pourra être appelée depuis une JVM autre que la JVM locale.

HelloServeur.java implémente cette interface :

public class HelloServeur extends UnicastRemoteObject

      implements Hello

 

Pour compiler ces trois fichiers, faire :

javac *.java

On obtient alors  :

Hello.class    HelloServeur.class  HelloClient.class   

Les versions actuelles de RMI génèrent automatiquement la souche pour les clients et le squelette pour les serveurs. Ces fichiers ne sont donc pas/plus visibles.

Maintenant, en étant dans le répertoire où se trouvent les fichiers .class :

• sur la machine localhost, lancer rmiregistry en arrière plan, en donnant un numéro de port particulier : 20000.
• lancer le serveur sur la même machine que rmiregistry , toujours sur la machine locale donc.
• lancer le client sur la même machine.

Ainsi, sur la machine 22hp001  :

rmiregistry 20000&

java  HelloServeur  20000 coucou

le serveur répond :

HelloServeur enregistre : //22hp001.univ-brest.fr:20000/HelloServeur

Sur cette même machine, depuis le même répertoire :

java HelloClient 20000 22hp001 

le client répond :

 Connexion au service : //22hp001.univ-brest.fr:20000/HelloServeur

On voit alors apparaître la message coucou émis par le serveur.

Remarque :
Là où se trouvent les sources, il y a un fichier Makefile qui automatise les commandes précédentes...

 

I.2 Questions

Pour faciliter la résolution des exercices suivants, répondez aux questions suivantes :

1. Identifiez dans le programme l'instanciation de l'objet, son activation et sa publication vers le serveur de noms ?
2. Identifiez dans le programme la récupération de la souche et l'invocation du service de noms.
3. A quoi sert le fichier MyHostName.java ?

II. Utilisation élémentaire de RMI

Récupérez les fichiers de cet exercice à partir de ce répertoire . Sauvez tous ces fichiers dans un répertoire EXO2. Dans ce premier exercice, on vous demande d'implanter un serveur permettant de gérer un compte bancaire. Le serveur propose une interface (voir le fichier Compte.java) qui permet aux clients de :

• Débiter ou créditer le compte d'un montant donné.
• Consulter le solde du compte.

Travail à faire :

• Ecrire la classe CompteServeur.java qui implante l'interface Compte.java et qui démarre un serveur permettant de répondre à des clients RMI distants.
• Completez la classe Client.java. Testez votre serveur.

III. Usine à objets

Récupérez les fichiers de cet exercice à partir de ce répertoire . Sauvez tous ces fichiers dans un répertoire EXO3. On regarde comment construire une usine à objets avec Java RMI. Une usine à objets est un objet invocable à distance dont la fonction est d'instancier d'autres objets invocables à distance.

On se propose d'illustrer la notion d'usine en réalisant un programme dont le but est d'instancier des piles d'entier. Pour ce faire, vous devez implanter les interfaces UsinePile et Pile.

La méthode creation_pile de l'interface UsinePile permet de créer des objets de type Pile. Chaque objet de type Pile doit être publié au service de nom grâce au nom passé en argument lors de l'appel de la méthode creation_pile. Les piles ainsi créées stockent des entiers. On suppose qu'une pile à une taille maximale précisée à sa création.

L'interface Pile permet de manipuler une pile après sa création. On y trouve les méthodes classiques :

• D'insertion (la méthode empiler). L'insertion dans une pile pleine doit lever une exception dont le message est "Pile pleine". Pour lever une exception qui soit propagée du serveur au client, il suffit d'instancier la classe java java.rmi.RemoteException avec l'instruction throw new. La chaîne de caractères passée au constructeur de cette classe constitue le message qui sera transmis au client.
• D'extraction (la méthode depiler). L'extraction sur une pile vide doit lever une exception dont le message est "Pile vide".
• De consultation du dernier élément inséré (la méthode haut). La consultation sur une pile vide doit lever une exception dont le message est "Pile vide".
• Permettant de vider la pile (la méthode vider).
• D'accesseurs sur le nombre d'éléments actuellement mémorisés dans la pile ainsi que sa taille maximale (méthodes lire_taille_courante et lire_taille_max).

Travail à faire :

• Ecrire les classes PileImpl.java et UsinePileImpl.java qui implantent respectivement les interfaces Pile et UsinePile et qui démarrent un serveur permettant de répondre à des clients RMI distants.
• Testez avec le programme Java Client.java.

IV. Objets sérialisables

Récupérez les fichiers de cet exercice à partir de ce répertoire . Sauvez tous ces fichiers dans un répertoire commun EXO4.

Une des particularités de Java RMI est la possibilité de transférer des objets par copie entre les clients et les serveurs (ce qui n'est pas possible avec CORBA). Les objets échangés par copie doivent implanter une interface qui étend l'interface standard Serializable : on parle d'objets sérialisables ("mise en série" des données). Attention : les objets sérialisables ne peuvent pas être invoqués par un client situé sur une machine distante. : ils sont passés par copie au client.

Attention : il ne faut pas confondre les objets Serializable qui sont donc passés pas copie et les objets Remote qui sont invoqués à distance.

Nous illustrons ce point en reprenant l'exercice III mais cette fois-ci, il ne s'agit plus de gérer des piles mémorisant des entiers : les piles mémorisent maintenant des objets implantant l'interface PileDonnee. Pour ce faire, vous disposez d'une nouvelle version de l'interface Pile.

Travail à faire :

• Modifiez la classe qui implante l'interface Pile afin que votre serveur puisse maintenant gérer des piles de PileDonnee.
• Etudiez les clients Creation.java et Affiche.java. Que font ces deux programmes ?
• Testez votre solution avec Creation.java et Affiche.java.

V. Exercice de synthèse

Ce dernier exercice fait la synthèse des exercices précédents. L'application à réaliser est constituée d'objets accessibles à distance (objets Remote) et d'objets passés par copie (objets Serializable). Il s'agit de mettre en place une application qui mémorise les résultats académiques d'un ensemble d'étudiants.

Pour ce faire, récupérez les fichiers de cet exercice à partir de ce répertoire. Sauvez ces fichiers dans un répertoire commun EXO5.

Cette application est constituée de deux interfaces : Etudiant.java et Promotion.java. L'interface Etudiant.java donne accès aux données associées à un étudiant : c'est à dire son nom, son prénom, son numéro d'étudiant ainsi qu'un ensemble de notes. Chaque étudiant passe plusieurs épreuves. Chaque épreuve donne lieu à une note. Chaque note est associée à un coefficient. Un coefficient est un double dont la valeur est comprise entre 0 et 1. La somme des coefficients de toutes les épreuves d'un étudiant doit être égale à 1. Ces différentes épreuves sont stockées dans un ensemble d'instance de la classe Epreuve_avec_coeff.java. L'interface Etudiant.java propose trois méthodes:

• ajouter_une_epreuve: qui permet d'ajouter une épreuve à un étudiant. Une épreuve est constituée d'un nom (ex: "Ecrit de math"), d'une note et d'un coefficient indiquant le poids de l'épreuve dans la moyenne générale de l'étudiant.
• liste_des_epreuves: qui renvoie au client un tableau de chaines de caractères contenant la liste des épreuves associées à l'étudiant. On retourne ici le nom de chaque épreuve qui peut être obtenu par la méthode afficher.
• calculer_la_moyenne: qui calcule la moyenne générale de toutes les épreuves d'un étudiant conformément aux coefficients de chaque épreuve.

L'interface Promotion.java permet:

• De créer un nouvel étudiant (méthodeajouter_un_etudiant).
• De rechercher un étudiant précédemment enregistré (méthoderechercher_un_etudiant). Grâce à la référence d'objet ainsi récupérée, le client peut alors demander le calcul de la moyenne générale de l'étudiant.
• De calculer la moyenne générale de toute la promotion (méthode calculer_moyenne_de_la_promotion ).

Travail à faire :

• Proposez un serveur ainsi qu'une classe d'implémentation pour chacune des interfaces accessibles à distance.
• Proposez un client qui déclare plusieurs étudiants ayant passés plusieurs épreuves. Puis, testez votre solution en affichant les épreuves, la moyenne de chaque étudiant ainsi que la moyenne générale de la promotion.

Page maintenue par Frank Singhoff(singhoff@univ-brest.fr)
Dernière mise à jour le 3 février 2023