Examen de Java Correction

Examen de Java
Correction
FIUPSO 3/DESS – Ann´ ee 2001/2002
Hugues MOUNIER
1 f´ evrier 2002
Modalit´
es
–Dur´ ee: 4 heures
– Tous les documents sont autoris´
es.
– Les sources java r´
epondant ` a chaque exercice, et seulement les sources seront obli-
gatoirement copi´ es dans le r´
epertoire examenjava (tout en minuscules) cr´
ee `
a la
racine de votre compte.
Solution de l’ex. 1 Calculatrice
Voici une solution possible:
// Gestion simpliste de banque utilisant des sockets
import java.util.*;
import java.io.*;
public class Calculette {
static double resultat = 0;
/* methodes */
static int somme(int a, int b) { return(a+b); }
static int soustraction(int a, int b) { return(a-b); }
static int multiplication(int a, int b) { return(a*b); }
static double division(int a, int b) { return(a/b); }
public static void main(String args[]) {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// Boucle infinie
for(;;) {
try {
// Afficher une invite a l’utilisateur
System.out.println("1 Somme de deux entiers\n" +
"2 Soustraction de deux entiers\n" +
"3 Multiplication de deux entiers\n" +
"4 Division de deux entiers\n" +
"5 Sortie du programme\n\n" +
"Veuillez entrer votre choix :\n");
// Lire une ligne entree par l’utilisateur
String line = in.readLine();
1

Examen Java FIUPSO 3/DESS 2001/2002
// Si l’on rencontre une fin de fichier, ou si l’utilisateur
// entre "quit", on sort
if ((line == null) || line.equals("5")) break;
// On essaie de formatter l’entree de l’utilisateur,
int choix = Integer.parseInt(line);
System.out.print("Veuillez entrer le 1er entier : ");
line = in.readLine();
int x = Integer.parseInt(line);
System.out.print("Veuillez entrer le 2eme entier : ");
line = in.readLine();
int y = Integer.parseInt(line);
switch(choix) {
case 1 : resultat = somme(x, y); // Somme
break;
case 2 : resultat = soustraction(x, y); // Soustraction
break;
case 3 : resultat = multiplication(x, y); // Multiplication
break;
case 4 : resultat = division(x, y); // Division
break;
}
System.out.println("Resultat : " + resultat);
}
// Affichage d’un message d’erreur en cas de probleme
catch(Exception e) { System.out.println("Entree Invalide"); }
}
}
}
Gestion de banque en client/serveur par sockets
L’objet des exercices qui suivent est de d´
evelopper une application de gestion bancaire
simple en r´
eseau, utilisant les sockets. Ce dernier m´
ecanisme n’offrant que du transfert de
flux, donc d’assez bas niveau, il est n´ ecessaire de concevoir un protocole permettant de
diff´ erentier les diff´
erentes op´
erations bancaires tout en acheminant les donn´ ees pertinentes.
Ce type de conception ne serait pas n´ ecessaire si l’on prenait des invocations de m´ ethodes
distantes (RMI), bien que l’on perde ´ evidemment en souplesse de conception.
Pour r´
ealiser l’objectif vis´
e, on se fondera sur l’exercice de gestion bancaire en local. On
repr´ esentera un paquet par une classe d´
ecrite ci-dessous.
Solution de l’ex. 2 Paquets `
a´
echanger
Une solution possible est la suivante :
// Gestion simpliste de banque utilisant des sockets
import java.util.*;
import java.io.*;
/**
* Classe pour stocker les donnees d’un compte bancaire
**/ class Account {
String password; // mot de passe
int balance; // solde du compte
Vector transactions = new Vector(); // historique des transactions
Hugues MOUNIER 2

Examen Java FIUPSO 3/DESS 2001/2002
Account(String password) {
this.password = password;
this.balance = 0;
transactions.addElement("Compte ouvert le " + new Date());
}
}
/**
* Classe representant un paquet du protocoloe bancaire
**/
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
BankSocketPacket(String theName, int theOperation,
String thePassword, int theAmount) {
name = theName;
operation = theOperation;
password = thePassword;
amount = theAmount;
}
public String foldPacket() {
String foldedPacket;
StringBuffer tobeFolded = new StringBuffer();
tobeFolded.append(this.name).append(":");
Integer opCode = new Integer(this.operation);
tobeFolded.append(opCode.toString());
if (password != null) {
tobeFolded.append(":").append(this.password);
}tobeFolded.append(":").append(this.amount);
tobeFolded.append("#");
foldedPacket = new String(tobeFolded);
return(foldedPacket);
}
public void unfoldPacket(String foldedPacket) {
Hugues MOUNIER 3

Examen Java FIUPSO 3/DESS 2001/2002
String unfoldedTab[] = new String[4];
/* Le deballage est d’abord effectue dans un tableau de String */
int current = foldedPacket.indexOf(’:’, 0);
int next = foldedPacket.indexOf(’:’, current+1);
int last = current;
int i = 1;
unfoldedTab[0] = foldedPacket.substring(0, current);
while (next != -1) {
unfoldedTab[i++] = foldedPacket.substring(current+1, next);
last = current;
current = foldedPacket.indexOf(’:’, last+1);
next = foldedPacket.indexOf(’:’, current+1);
}
unfoldedTab[i] = foldedPacket.substring(current+1, foldedPacket.length()-1);
/* On remplit les champs du paquet deballe */
try { name = new String(unfoldedTab[0]);
operation = Integer.parseInt(unfoldedTab[1]);
password = new String(unfoldedTab[2]);
amount = Integer.parseInt(unfoldedTab[3]);
} catch (NumberFormatException e) {
System.err.println("Erreur en unfoldPacket()--parseInt() : ");
System.err.println(e);
System.exit(1);
}
}
/* Test */
/*
public static void main(String[] args) {
Account cpte = new Account("issos");
BankSocketPacket packet = new BankSocketPacket("Alexandre", cpte, OPEN);
String aAfficher = packet.foldPacket();
System.out.println(aAfficher);
String[] deballe = BankSocketPacket.unfoldPacket(aAfficher);
for(int i = 0; i < deballe.length; i++)
System.out.println(deballe[i]);
}
*/
}
Solution de l’ex. 3 ´ Elaboration du serveur
Une solution possible est la suivante :
// Serveur Bancaire simpliste en sockets
import java.util.*;
import java.io.*;
import java.net.*;
/**
* Cette classe implante les methodes distantes definies par l’interface
* RemoteBank. Son plus gros defaut est que toutes les informations sur les
Hugues MOUNIER 4

Examen Java FIUPSO 3/DESS 2001/2002
* comptes sont perdues lorsque le serveur s’arrete.
**/
public class BankServerSocket
{public final static int DEFAULT_PORT = 6789;
Hashtable accounts = new Hashtable();
static int transCode;
/**
* Ouvre un compte avec le nom et le mot de passe specifie
* Cette methode est synchronisee de facon qu’une seule thread
* ne modifie a la fois la table des comptes.
**/
public synchronized void openAccount(String name, String password) {
// Verifier s’il exsite deja un compte ayant ce nom
if (accounts.get(name) != null) {
transCode = BankSocketPacket.EXISTANT;
return;
}
// S’il n’existe pas, le creer
Account acct = new Account(password);
// Et l’enregsitrer
accounts.put(name, acct);
transCode = BankSocketPacket.TRANSOK;
}
/**
* Cette methode utilitaire n’est pas une methode accessible de maniere
* distante. Etant donnes un nom et un mot de passe, verifie s’il existe
* un compte correspondant. Si oui, renvoie l’objet Account. Sinon,
* leve une exception.
**/
public Account verify(String name, String password) {
synchronized(accounts) {
Account acct = (Account)accounts.get(name);
if (acct == null) {
transCode = BankSocketPacket.NONEXISTANT;
return null;
}
if (!password.equals(acct.password)) {
transCode = BankSocketPacket.INVPASSWORD;
return null;
}
transCode = BankSocketPacket.TRANSOK;
return acct;
}
}
/**
* Ferme le compte dont on donne le nom. Methode synchronisee
**/
public synchronized FunnyMoney closeAccount(String name, String password) {
Account acct;
acct = verify(name, password);
if (acct != null) {
accounts.remove(name);
synchronized (acct) {
int balance = acct.balance;
Hugues MOUNIER 5