Gestion distribuée (par sockets) de banque en Java

Université Paris Sud

Rappel sur la solution locale de gestion simple de banque

L’objet de cet exercice était de créer une application java qui implante quelques services
de base d’une gestion bancaire, c’est-à-dire :
1. Créer deux classes principales BankLocal et BankLocalServer qui vont agir
respectivement comme client et comme serveur (en local). Seule BankLocal sera
déclarée publique.
2. Créer une classe Account, représentant un compte bancaire, munie des champs
String password, le mot de passe associé au compte et int balance le solde
du compte. Cette classe ne contiendra qu’un constructeur et aucune autre méthode.
Ce constructeur ne sera chargé que d’enregistrer le mot de passe et d’initialiser le
solde à zéro.
3. L’ensemble des comptes bancaires sera stocké dans une table de hachage (Hashtable)
réalisant l’association nom du titulaire d’un compte – objet de type Account (le
compte, informatiquement parlant). Cette table sera le seul champ de la classe
BankLocalServer, nommé allAccounts.
4. Créer une exception BankingException qui hérite d’exception et qui ne définit
qu’un seul constructeur (et aucune autre méthode) BankingException(String)
qui appelle le constructeur de la classe mère. Cette exception servira pour des cas
tels que “Solde insuffisant” ou “Mot de passe invalide”.
5. Prévoir les opérations suivantes comme méthodes de BankLocalServer (ce sont
les opérations réalisées au sein même de la banque) :
– Ouverture de compte par la méthode
public void openAccount(String name, String password)
throws BankingException.
Le nom du titulaire name est donné en premier argument et son mot de passe
password en deuxième argument. La méthode réalise la vérification d’un compte
ayant déja le même nom de titulaire, auquel cas elle lève une exception de type
BankingException et dans le cas contraire crée le compte et l’enregistre dans
la table allAccounts.
– Une méthode utilitaire de vérification d’existence de compte et de mot de passe
valide : public Account verify(String name, String password)
throws BankingException.
Si le compte de nom name n’existe pas (dans account) ou si le mot de passe
password est différent de celui trouvé dans allAccounts comme correspondant
à name, la méthode génère une exception de type BankingException. Sinon,
elle renvoie une référence sur l’objet de type Account correspondant.

1
2 Gestion distribuée (par sockets) de banque en Java

– Fermeture de compte par la méthode

public int closeAccount(String name, String password)
throws BankingException.
Elle effectue une vérification à l’aide de verify(...), retire le compte de la
table allAccounts, met le solde à zéro et renvoie le montant disponible.
– Dépot d’argent sur un compte par la méthode
public void deposit(String name, String password,
int money) throws BankingException.
Elle effectue une vérification à l’aide de verify(...) et incrémente le solde du
montant money déposé.
– Retrait d’argent sur un compte par la méthode
public int withdraw(String name, String password,
int amount) throws BankingException.
Elle effectue une vérification à l’aide de verify(...), vérifie que le solde est
suffisant pour le montant du retrait (dans le cas contraire, elle genère une excep-
tion de type BankingException), décrémente le solde du montant amount et
renvoie le montant retiré.
– Obtention du solde d’un compte par la méthode
public int getBalance(String name, String password)
throws BankingException.
Elle effectue une vérification à l’aide de verify(...), puis renvoie le solde du
compte.
6. La méthode main(...) se trouvera dans BankLocal et proposera à l’utilisateur
un menu textuel afin qu’il puisse gérer son compte. Les entrées seront effectuées avec
des readLine() (sur une référence créée comme suit BufferedReader stdin
= new BufferedReader(new InputStreamReader(System.in)) ;) et les
sorties seront effectuées avec des System.out.println(...)
7. Gestion des synchronisations.
Quelles méthodes doivent être synchronisées et dans lesquelles peut-on se contenter
de ne synchroniser qu’un bloc afin d’assurer l’accès en exclusion mutuelle à un objet ?
Modifier le code de façon à obtenir des accès synchronisés.
8. Question subsidiaire : gestion des transactions.
Effectuer un historique des transactions à l’aide d’un nouveau champ de Account,
de type Vector, nommé transactions. Mettre à jour le constructeur de Account
ainsi que les méthodes deposit(...) et withdraw(...). Créer une méthode
public Vector getTransactionHistory(String name,
String password) throws BankingException qui effectue une vérification
à l’aide de verify(...), puis renvoie une référence sur le vecteur des transactions.

Gestion de banque en client/serveur par sockets

L’objet des exercices qui suivent est de développer une application de gestion bancaire
simple en réseau, utilisant les sockets. Ce dernier mécanisme n’offrant que du transfert de
flux, donc d’assez bas niveau, il est nécessaire de concevoir un protocole permettant de
différentier les différentes opérations bancaires tout en acheminant les données pertinentes.
Ce type de conception ne serait pas nécessaire si l’on prenait des invocations de méthodes
distantes (RMI), bien que l’on perde évidemment en souplesse de conception.
Exercice 1 – Paquets à échanger 3

Pour réaliser l’objectif visé, on se fondera sur l’exercice de gestion bancaire en local.
On représentera un paquet par une classe décrite ci-dessous.

Exercice 1 Paquets à échanger

On crééra une classe BankSocketPacket représentant un paquet du protocole ban-
caire. Voici une spécification de cette classe :
public class BankSocketPacket {
String name; // nom du compte
int operation; // operation bancaire
String password; // mot de passe
int amount; // solde

/* Operations */
public static final int OPEN = 1; // Ouverture de compte
public static final int CLOSE = 2; // Fermeture de compte
public static final int DEPOSIT = 3; // Depot sur un compte
public static final int WITHDRAW = 4; // Retrait sur un compte
public static final int BALANCE = 5; // Solde d’un compte
public static final int QUIT = 6; // Sortie du programme
/* Erreurs */
public static final int TRANSOK = 0; // Transaction bien passee
public static final int EXISTANT = -1; // Overture de compte deja existant
public static final int NONEXISTANT = -2; // Operation sur compte inexistant
public static final int INVPASSWORD = -3; // Mot de passe invalide
public static final int NEGBALANCE = -4; // Solde insuffisant pour retrait

/** Constructeur : initialisation des champs **/

BankSocketPacket(String theName, int theOperation,
String thePassword, int theAmount) { ... }

/** Constructeur par defaut : paquet "vide" **/

BankSocketPacket() { ... }

/** Empaquetage ou formation du paquet : BankSocketPacket -> String **/

public String foldPacket() { ... }

/** Depaquetage ou deballage du paquet : String -> BankSocketPacket **/

public void unfoldPacket(String foldedPacket) { ... }

Outre les champs name, password et amount qu’on trouvait déja en solution locale, nous
ajoutons un champ entier operation représentant le type d’opération bancaire à réaliser.
Les différents types d’opérations possibles sont listés en constantes (public static
final int) strictement positives. Les erreurs de type bancaire pouvant survenir sont
représentées par des constantes strictement négatives et une constante nulle (TRANSOK)
signifie une transaction qui s’est bien passée.
Considérons un paquet ayant les champs suivants : name valant "Diogene", password
valant "tonneau" et amount valant 1. Supposons que le compte a été ouvert et que l’on
veuille déposer (DEPOSIT) un montant de 100 sur le compte. Pour transmettre le paquet,
on le transforme en la chaîne de caractères formée en mettant bout à bout les champs,
séparés par le caractère : (deux-points). Ceci donne pour l’exemple ci-dessus
"Diogene:3:tonneau:100#". Le deuxième champ est la valeur de la constante associée
4 Gestion distribuée (par sockets) de banque en Java

à l’opération DEPOSIT désirée, 3. Le dernier caractère # est un séparateur de paquets.

On représentera donc un paquet générique transmis comme suit :
"name:OPERATION:password:amount#"
Le champ amount aura une signification différente selon les opérations à réaliser. Les
significations selon l’opération à réaliser (ou l’erreur survenue) sont consignées ci-dessous
OPERATION Signification du champ amount
OPEN Aucune
CLOSE Aucune
DEPOSIT Montant à déposer
WITHDRAW Montant à retirer
BALANCE Solde du compte
QUIT Aucune
TRANSOK Aucune
EXISTANT Aucune
NONEXISTANT Aucune
INVPASSWORD Aucune
NEGBALANCE Aucune

A part le constructeur, la classe comporte deux méthodes utilitaires : foldPacket()

qui convertit l’objet appelant (de type BankSocketPacket) en une chaîne (de type
String) qui sera transmise dans le réseau, et unfoldPacket() qui réalise l’opération
inverse.
Écrire le code des méthodes utilitaires foldPacket() et unfoldPacket(). On
pourra se servir, pour foldPacket(), des méthodes append() de StringBuffer,
toString() de Integer. On pourra se servir, pour unfoldPacket(), des méthodes
indexOf() et substring() de la classe String si l’on souhaite faire le déballage “à
la main”, ou bien alors des méthodes replaceAll() de String et useDelimiter(),
next() et nextInt() de Scanner.

Exercice 2 Élaboration du serveur

Le schéma de fonctionnement est le suivant : le client envoie une requête au serveur,
qui la traite et qui renvoie une réponse. Cette réponse peut correspondre à une erreur
ou à une transaction qui s’est bien réalisée. Par exemple, supposons qu’un compte de
nom Diogene et de mot de passe tonneau ait été créé. Supposons vouloir déposer
un montant de 100 pièces de monnaie sur ce compte sur lequel il y a déja 150 pièces.
Si l’on envoie la chaîne "Diogene:3:tonneau:100#" au serveur, ce dernier répondra
"Diogene:0:tonneau:250#" Si par contre l’on se trompe sur le mot de passe et que l’on
envoie "Diogene:3:maison:100#", le serveur répondra "Diogene:-3:maison:100#"
sachant que le deuxième champ est la constante BankSocketServer.INVPASSWORD
représentant une erreur de mot de passe invalide. Le client affichera alors un message cor-
respondant à l’erreur survenue. On crééra un serveur itératif, ne traitant qu’un seul client
à la fois.
Créer une classe BankSocketServer qui représente le serveur bancaire, dont les
spécifications seront les suivantes :
public class BankServerSocket {
public final static int DEFAULT_PORT = 6789; // No de port par defaut
Hashtable allAccounts = new Hashtable(); // table des comptes
Exercice 2 – Élaboration du serveur 5

static int transCode; // code d’erreur

public synchronized void openAccount(String name, String password) { ... }

public Account verify(String name, String password) { ... }

public synchronized int closeAccount(String name, String password) { ... }

public void deposit(String name, String password, int money) { ... }

public int withdraw(String name, String password, int amount) { ... }

public int getBalance(String name, String password) { ... }

/* Methode d’envoi de paquet */

void sendPacket(BankSocketPacket toSend, PrintStream out) { ... }

/* Methode de reception de paquet */

BankSocketPacket receivePacket(BufferedReader in) {...}

public static void main (String[] args) throws IOException { ... }

}// BankServerSocket

On distingue trois champs : outre le numéro de port par défaut et la table des comptes
(déja présente dans la solution locale et qui réalise la correspondance nom/objet de type
Account), on dispose d’un champ entier qui code l’apparition d’une erreur. On rap-
pelle à ce propos que les constantes de la classe BankSocketPacket sont statiques et
doivent donc être appelées en plaçant le nom de la classe devant ; par exemple la constante
BankSocketPacket.TRANSOK désigne une transaction qui s’est bien passée.
Dans les différentes méthodes que l’on trouvait déja dans la solution locale, le traite-
ment d’erreurs effectué par un traitement d’exception de type BankingException est
remplacé par l’affectation de transCode au code de l’erreur correspondante. Les deux
seules méthodes nouvelles sont sendPacket() et receivePacket() pour l’envoi et la
réception des packets. Plus précisément, une fois le paquet à envoyer créé (par un new
BankSocketPacket(...)), sendPacket() est chargée des opérations suivantes :
– emballage du paquet, c.à.d. création à l’aide de la méthode foldPacket() (mé-
thode de la classe BankSocketPacket) d’une chaîne du type
"name:OPERATION:password:amount#" ;
– envoi de cette chaîne au client via la méthode println() de la classe PrintStream.
De son coté, receivePacket() est chargée des opérations suivantes :
– Réception d’une requête via la méthode readLine().
– Création d’un paquet “vide” (par le constructeur par défaut de BankSocketPacket).
– Déballage du paquet par appel de la méthode unfoldPacket().
Enfin, la méthode main(), outre les traitements classiques, effectuera les actions sui-
vantes au sein de son service :
– Appel de receivePacket().
– Branchement selon l’opération demandée selon un switch.
– Appel de la méthode correspondant à l’opération demandée (c’est-à-dire : openAccount(),
closeAccount(), deposit(), withdraw(), getBalance() ou, dans le cas de
sortie, des close() de sockets).
– Création d’un paquet avec les champs adéquats.
6 Gestion distribuée (par sockets) de banque en Java

– Envoi du paquet au client.

Exercice 3 Élaboration du client

Créer une classe BankSocket dont les spécifications sont les suivantes :
public class BankSocket {
// Variables de classe constantes : port et machine par defaut
public static final int DEFAULT_PORT = 6789;
public static final String DEFAULT_HOST = "localhost";

// Methode utilitaire de saisie

public String getName(BufferedReader in) { ... }

// Methode utilitaire de saisie

public String getPassword(BufferedReader in) { ... }

// Methode utilitaire de gestion d’erreur

static void treatError(int errorNb) { ... }

// Methode utilitaire d’envoi/reception de paquet

BankSocketPacket sendReceive(BankSocketPacket toSend,
DataInputStream sin, PrintStream sout, String message) { ... }

public static void main(String[] args) { ... }

Les méthodes getName() et getPassword() sont des méthodes de saisie qui de-
mandent respectivement à l’utilisateur d’entrer sur l’entrée standard (au clavier) un nom et
un mot de passe ; la chaîne de caractère entrée est renvoyée. La méthode treatError()
affiche un message sur la sortie standard correspondant au code d’erreur fourni en para-
mètre. La méthode sendReceive() effectue les actions suivantes :
– Emballage du paquet toSend par la méthode foldPacket() (1er paramètre).
– Envoi du paquet emballé par println() sur sout (2e paramètre, représentera le
flux de sortie vers le serveur dans le code qui appelle la méthode).
– Réception d’une ligne par readLine() sur sin (3e paramètre, représentera le flux
d’entrée en provenance du serveur dans le code qui appelle la méthode).
– Déballage de la ligne reçue par unfoldPacket() après création d’un paquet via
le constructeur par défaut de BankSocketPacket.
– Test sur le code (champ operation) du paquet juste déballé : s’il est égal au code
BankSocketPacket.TRANSOK, affichage du message message, sinon appel de la
méthode treatError() avec pour argument ce code.
– Renvoi (return()) du paquet déballé.
Au sein de la méthode main(), outre les traitements usuels pour un programme client
par sockets, le traitement du service comprend :
– Affichage des différentes opérations possibles et prise d’entrée (choix) de l’utilisateur
– Choix selon l’opération souhaitée. Puis, au moins :
– prise des nom et mot de passe via getName() et getPassword() ;
– création d’un paquet par le constructeur de BankSocketPacket en y mettant les
noms, mot de passe et opération sélectionnés ;
Exercice 3 – Élaboration du client 7

– appel de sendReceive() pour envoyer le paquet précédent et recevoir la réponse

du serveur.