JAVA : Un peu d’histoire
Le langage Java fut développé par Sun Microsystems en
1991 dans le cadre du projet Green, groupe de recherche
spécialisé dans le développement de logiciels conçus pour
contrôler des appareils électroniques
En 1994 les membres du projet Green ont crée un
navigateur Web capable de faire fonctionner des applets
Java, initialement appelé WebRunner, et qui a été
renommé après en HotJava
1
JAVA : Caractéristiques
Java est un langage de programmation orientée objet
doté d’une gigantesque bibliothèque de « classes»
Permet la création aisée des interfaces graphiques
Il permet la création d’applications « multithread »
Application distribuées complexes qui tournent autour
d’internet: Forum, partage de BDD, jeux, systèmes
embarquées..
Java assure la sécurité et garantit à l'utilisateur un niveau
de protection élevé pour son système
2
JAVA : Caractéristiques
La simplicité : Java a été conçu de façon relativement
proche de C++ pour faciliter la compréhension du système
Conçu pour fonctionner sur le Web : Applets
Les applets peuvent servir à créer des animations, des
figures, des jeux, des formulaires capables de réagir à des
informations entrées par l'utilisateur
Un langage indépendant de toute plateforme : un
programme java peut fonctionner sur différentes plates-
formes et différents systèmes d’exploitations 3
JAVA : Composantes
Programmes multi plates formes Java: grâce à l’utilisation
d’une machine virtuelle Java.
Une machine virtuelle est une sorte d’ordinateur (machine)
installé à l’intérieur de l’ordinateur physique de l’utilisateur.
Rôle : une machine virtuelle prend les programmes Java
compilés et convertit leurs instructions en commandes
compréhensibles pour un système d'exploitation
4
JAVA : Caractéristiques
Le pseudo code java indépendant de toute plateforme
5
JAVA : Compilation en Bytecode
Le Bytecode (ou pseudo-code) : le compilateur Javac
traduit le programme source [Link] en un code
intermédiaire [Link] indépendant de toute
machine physique (non exécutable directement, Besoin
d’une machine virtuelle)
6
JAVA : Compilation native
La Compilation native: consiste en la traduction de la
source java en langage binaire exécutable sur la plate-
forme concernée
7
JAVA : La machine virtuelle java
La machine virtuelle JAVA: aussi
appelée interpréteur Java, se charge
d’exécuter le programme source java
traduit en bytecode sur la machine
physique à travers son système
d'exploitation (Windows,
Unix,MacOs,...).
8
JAVA : Java Développement Kit (JDK)
Le JDK regroupe l'ensemble des éléments permettant le
développement, la mise au point et l'exécution des
programmes Java.
Compilation et exécution de type ligne de commande
Compilation en utilisant : javac [Link]
le pseudo code Java est enregistré sous le nom
[Link]
Execution : java [Link]
9
JAVA : Java et la programmation réseau
Java fournit plusieurs classes et interfaces destinées à la
programmation réseau
Plusieurs domaines d'application pouvant être programmé
aisément avec JAVA:
• Navigation sur l'Internet (HTTP).
• Messagerie électronique (SMTP et POP)
• Conception de nouveaux protocoles.
• Transfert de fichiers (FTP).
• Sécurité des communications (Cryptage des messages.
10
JAVA : Java et la programmation réseau
JAVA est le premier langage qui a fourni une bibliothèque
riche et puissante et multi plateforme qui couvre divers
domaines comme ceux qui sont cités ci-dessus.
Les classes et interfaces utiles au développement réseau sont
regroupées dans le package [Link]. Les classes utilisées sont :
InetAddress, NetworkInterface : pour l'adressage IP
Socket et ServerSocket pour les protocole TCP.
DatagramPacket, DatagramSocket pour UDP.
URL, URLConnection,,… pour la couche application
11
JAVA : Les exceptions
• Une exception est une erreur se produisant dans un
programme qui conduit le plus souvent à l'arrêt de celui-ci.
• Une exception, si elle n’est pas capturée, il va y avoir
affichage d’un gros message en rouge dans la console.
L’implémentation des exceptions en général se fait à l’aide
des blocs try{} et catch{}
L’utilisation de plusieurs classes peut s’avérer nécessaire
pour mieux capturer les exception, et plus particulièrement
des exceptions en relation avec des opération d’E/S
échouées ou interrompues
La Classe IOException (import [Link];)
12
Java : Les exceptions liées au réseau
13
La classe InetAddress
14
La classe InetAddress
Exercice
Ecrire un programme permettant de :
1. Afficher l’adresse IP locale de la machine
2. Afficher le nom de la machine locale
3. Afficher l’adresse IP du site de l’ENSA de Tanger
4. Afficher les @ IP des miroirs du site [Link]
Utiliser les methodes suivantes:
[Link]();
getHostAddress()
getHostName()
[Link]("[Link]")
[Link]("[Link]")
15
import [Link].*; La classe InetAddres
public class Exemple_InetAddress {
public static void main(String[] args) {
try { // Renvoi l'adresse de la machine locale
InetAddress Adresse_Locale = [Link]();
[Link]("L'addrsse de la machine locale = " +
Adresse_Locale.getHostAddress());
// Renvoi le nom de la machine locale
[Link]("Le nom de la machine locale = " +
Adresse_Locale.getHostName());
// Renvoi l'adresse IP du serveur de l'université Abdelmalek Essaadi
InetAddress Adresse_Serveur = [Link]("[Link]");
[Link]("L'adresse de l'ENSA de TANGER = "+
Adresse_Serveur.getHostAddress());
// Renvoi les adresses du serveurs Google
InetAddress[] Adresses_Serveurs = [Link]("[Link]");
[Link]("Les adresses du Google : ");
for (int i = 0; i < Adresses_Serveurs.length; i++)
[Link](" " + Adresses_Serveurs[i].getHostAddress());
} catch (Exception e) { [Link](); } } } 16
La classe InetAddres
Solution
17
La classe NetworkInterface
Enumeration <NetworkInterface> nets =
[Link]();
18
La classe NetworkInterface
Exercice:
Ecrire un programme permettant de récupérer la liste des
interfaces réseaux (Enumeration<NetworkInterface> nets =
[Link]();) et pour chaque
interface afficher les informations suivantes:
Nom court : getDisplayName();
La désignation : getName();
La liste des adresses IP associées à chacune des interfaces :
getInetAddresses();
19
import [Link].*;
import [Link].*;
La classe NetworkInterface
import [Link].*;
import static [Link];
public class Exemple_Interfaces {
public static void main(String args[]) throws SocketException {
Enumeration<NetworkInterface> nets =
[Link]();
for (NetworkInterface netint : [Link](nets))
displayInterfaceInformation(netint);
}
static void displayInterfaceInformation(NetworkInterface netint)
throws SocketException {
[Link]("Nom court: %s\n", [Link]());
[Link]("Désignation: %s\n", [Link]());
Enumeration<InetAddress> inetAddresses =
[Link]();
for (InetAddress inetAddress : [Link](inetAddresses))
{ [Link]("Adresse IP %s\n", inetAddress);
} [Link]("\n"); } } 20
La classe NetworkInterface
Solution:
21
JAVA et les sockets
Les Sockets sont des objets permettant la gestion de deux flux
de données :
un flux d'entrée (InputStream), garantissant la réception
des données,
un flux de sortie (OutputStream), servant à envoyer les
données.
Deux types de Socket:
les Sockets simples (dits "clients")
les Sockets serveurs.
Les Sockets représentent l'objet de base pour la
programmation TCP et UDP.
22
Les sockets TCP
23
Les sockets TCP :
La classe ServerSocket
24
Les sockets TCP :
La classe Socket
25
26
JAVA : La Classe Scanner
La Classe Scanner (import [Link];)
Elle simplifie la lecture de données sur l’entrée standard
(clavier) ou dans un fichier.
Ensuite il faut créer un objet de la classe Scanner :
Scanner scan = new Scanner([Link]);
Pour récupérer les données, il faut faire appel sur l’objet scan
aux méthodes permises:
• String next(): donnée de la classe String qui forme un mot,
• String nextLine(): donnée de la classe String qui forme une
ligne,
27
JAVA : La Classe Scanner
La Classe Scanner : Quelques méthodes
28
JAVA : La Classe Scanner
Lecture à partir de l’entrée standard [Link]
Lecture à partir d’un fichier new File([Link])
29
JAVA : Flux d’entrée
Une fois la connexion réalisée, il faut obtenir les Flux (streams)
d’E/S ([Link]) auprès de l’instance de la classe Socket en cours
obtention d’un flux (stream) simple: définit les op. de base
// (Communication par envoie d’octets)
InputSteam is = [Link]();
• création d’un flux convertissant les bytes reçus en char
InputSteamReader isr = new InputStreamReader(is);
création d’un stream de lecture avec tampon: pour lire ligne par
ligne dans un stream de caractères
BufferedReader br = new BufferedReader(isr);
lecture d’une chaîne de caractères String line = [Link]();
30
JAVA : Flux d’entrée
La Classe BufferedReader (import [Link];)
BufferedReader est une classe Java permettant de lire le texte d’un
flux d’entrée (comme un fichier, ou un flux de caractères) en
mettant sur le buffer de façon transparente un flux de caractères.
Permet d’obtenir le flux en entrée à partir d’une Socket.
BufferedReader in ;
in = new BufferedReader(new InputStreamReader([Link]()));
readline() : est une méthode sur un objet de type BufferedReader qui permettra
de lire une ligne.
read() : est une méthode sur un objet de type BufferedReader qui permet de lire
un caractère à partir d’un flux en entrée et retourne -1 si on atteint la fin de flux
31
JAVA : Flux d’entrée
BufferedReader in ;
in = new BufferedReader(new InputStreamReader([Link]()));
La Classe InputStreamReader ([Link];)
InputStreamReader établit un pont entre les flux d'octets et les flux de caractères .
Cette classe permet de lire des octets et les traduit en caractères en utilisant un
décodage spécifique(C’est une Classe de traitement et non de communication).
Un objet de type Scanner pourra remplacer l’utilisation de la classe
BufferedReader en obtenant directement un flux de caractère en entrée à partir
d’une Socket.
Scanner in = new Scanner([Link]());
32
import [Link].*;
public class Example_BufferedReader {
public static void main(String args[])throws Exception{
FileReader fr=new
FileReader("C:\\[Link]");
BufferedReader br=new BufferedReader(fr);
int i;
while((i=[Link]())!=-1){
[Link]((char)i);
}
[Link]();
[Link]();
}
}
33
JAVA : Flux de sortie
Obtention du flux de données sortantes : bytes
OutputSteam os = [Link]();
Création d’un stream convertissant les bytes en chaînes de
caractères
PrintWriter pw = new PrintWriter(os);
/* new PrintWriter(os,false): par défaut, les donnée sont stocké dans un Buffer et nécessite
l’utilisation de la méthode flush();
new PrintWriter(os,true):Envoie directe ligne par ligne
*/
Envoi d’une ligne de caractères
[Link](str);
Envoi effectif sur le réseau des bytes (important)
[Link]();
34
JAVA : Flux de sortie
La Classe PrintWriter (import [Link];)
La classe PrintWriter ajoute à un flux la possibilité de faire des
écriture sous forme de texte, et des chaînes de caractères.
Dans le cadre des sockets, il est souvent utilisé pour obtenir un
flux de sortie à partir de la socket.
35
import [Link];
import [Link];
public class Example_PrintWriter {
public static void main(String[] args) throws Exception {
//Data to write on Console using PrintWriter
PrintWriter writer = new PrintWriter([Link]);
[Link]("Test PrintWriter !!!.");
[Link]();
[Link]();
//Data to write in File using PrintWriter
PrintWriter writer1 =new PrintWriter(new File("C:\\[Link]"));
[Link]("Test l'ecriture dans un fichier en utilisant \n"
+ "la méthode Write sur un objet Print Writer!!!");
[Link]();
[Link]();
} }
36
JAVA : Flux de sortie (octets)
La Classe PrintStream (import [Link];)
• La classe PrintStream fournit des fonctionnalités supplémentaires
pour écrire des données formatées dans le flux de sortie sous-jacent.
• Tous les caractères imprimés par PrintStream sont convertis en
octets à l'aide du codage de caractères par défaut de la plateforme
PrintStream out = newPrintStream([Link]());
[Link]("Message à envoyer "); // println permet d’écrire le msg
[Link]();.
• L’appel de la méthode flush() d'un flux bufférisé est important et
permet de vider les buffers vers le medium de sortie, disque ou
réseau.
37
import [Link];
import [Link];
import [Link];
import [Link];
public class Example_PrintStream {
public static void main(String[] args) {
File file=new File("C:\\[Link]");
try {
FileOutputStream fileOS=new FileOutputStream(file);
PrintStream pS=new PrintStream(fileOS);
//Print date
[Link](new Date());
//Print newline
[Link]();
//Print String
[Link]("This an example of the PrintStream class");
} catch (Exception e) {
[Link]();} } }
38
Exemple de flux E/S vers et depuis une socket
try { Socket socket = new Socket(HOST,PORT);
//Lecture du texte depuis le flux d’entrée d’une socket
InputStreamReader isr = new InputStreamReader([Link]());
BufferedReader br = new BufferedReader(isr);
String line = [Link]();
//Ecriture du texte vers le flux de sortie d’une socket
PrintWriter pw = new PrintWriter([Link]());
[Link](line);
[Link]();
}catch (IOException e) {…}
finally {
try{[Link]();
}catch (IOException e){}}
40
Travaux Pratiques 1
Ecrire deux petits programmes, un programme qui devra s’exécuter
du coté serveur et un autre programme qui devra s’exécuter du coté
client.
Les deux programmes devront communiquer entre eux en utilisant
les sockets TCP en utilisant les classes Socket et ServerSocket.
• On utilisera les objets BufferedReader et PrintStream dans les deux
programmes pour gérer les flux d’entrée/Sortie depuis et vers le
socket client
// Obtention de flux en entrée et en sortie à partir du Socket.
BufferedReader in = new BufferedReader(
new InputStreamReader([Link]()));
PrintStream out = new PrintStream([Link]());
41
Exercice (Suite)
Le scénario d’échange de messages est le suivant :
1. Le Client se connecte à l’adresse du serveur (pour se faire, il devra
récupérer un objet InetAddress contenant l’@ du serveur
2. Le serveur accepte la connexion du Client en renvoyant une socket
3. Le serveur affiche l’@ du client et lui renvoie via le flux de sortie de
la socket Client la phrase suivante: Veuillez saisir votre compte :
4. Le Client reçoit cette phrase et l’affiche sur sa console et attend la
saisie du compte client sur l’entrée standard
5. L’utilisateur va saisir un nom de compte qui sera transmis au
serveur (Exemple: GSTR2)
6. Le serveur recevra le nom du compte et l’affichera sur sa sortie
standard (Compte d'utilisaeur : GSTR2)
7. Le serveur renvoi au client un message de bienvenue (Bienvenue
GSTR2)
8. Le Client et le serveur ferment la connexion
42
//Instanciation d'un objet ServerSocket
//Récupération d'un objet Socket à partir de la méthode accept();
//Echange de messages
//avec le serveur selon
//le scénario décrit
//Dans l’énoncé
//Fermeture du socket
43
44
//Instanciation d'un objet Scanner pour lire à partir du clavier
//Ouverture d’une socket avec le serveur (Machine Locale avec le port )
//Echange de messages
//avec le serveur selon
//le scénario décrit
//Dans l’énoncé
//…
//…
//…
45
46
Le scénario d’échange de messages
D’après le code déjà présenté, le scénario d’échange de
messages entre le client et le serveur doit être décrit au
moment de l’écriture du code
Une amélioration majeure du code consiste à donner la
possibilité de s’envoyer plusieurs messages
simultanément entre un Client et un Serveur.
Un astuce simple permettant d’accomplir cette mission
consiste à créer deux processus indépendant du coté
client et deux autres processus similaire du coté serveur
Un processus pour l’envoie et l’autre pour la réception 47
Les processus (Thread) en JAVA
Un thread est une unité d'exécution faisant partie d'un
programme. Cette unité fonctionne de façon autonome et
parallèlement à d'autres threads.
Le principal avantage des threads est de pouvoir répartir
différents traitements d'un même programme en plusieurs
unités distinctes pour permettre leurs exécutions
"simultanées".
48
Les processus (Thread) en JAVA
Sur une machine monoprocesseur, c'est le système
d'exploitation qui alloue du temps d'utilisation du CPU
pour accomplir les traitements de chaque threads, donnant
ainsi l'impression que ces traitements sont réalisés en
parallèle.
Sur une machine multiprocesseur, le système d'exploitation
peut répartir l'exécution sur plusieurs cœurs, ce qui peut
effectivement permettre de réaliser des traitements en
parallèle.
49
Les processus (Thread) en JAVA
L’interface Runnable : Cette interface doit être implémentée
par toute classe qui contiendra des traitements à exécuter
dans un thread.
Cette interface ne définit qu'une seule méthode : void run()
Dans les classes qui implémentent cette interface, la
méthode run() doit être redéfinie pour contenir le code des
traitements qui seront exécutés dans le thread..
La classe Thread est définie dans le package [Link]. Elle
implémente l'interface Runnable.
50
Les processus (Thread) en JAVA
La classe Thread : Elle possède plusieurs constructeurs : un
constructeur par défaut Thread() et plusieurs autres qui
peuvent avoir un ou plusieurs paramètres.
On s’intéressera plus particulièrement au constructeur
Thread(Runnable target)
La Classe Thread possède plusieurs méthodes:
• void interrupt(): Demander l'interruption du thread
• void run() : Contient les traitements à exécuter
• void start() : Lancer l'exécution des traitements :
associer des ressources systèmes pour l'exécution et
invoquer la méthode run()
51
Les processus (Thread) en JAVA
La Classe Thread possède plusieurs méthodes:
• static void sleep(long millis): Endormir le thread pour
le délai exprimé en millisecondes précisé en paramètre
• void suspend() : Suspendre le thread jusqu'au moment
où il sera relancé par la méthode resume( ).
• void resume() : Reprendre l'exécution du thread
préalablement suspendue par suspend( )
• void join() : Attendre la fin de l'exécution du thread
• .
• ..
• …
52
Les processus (Thread) en JAVA
1ère méthode: héritage de la classe Thread et redéfinition de la
méthode run().
Les processus (Thread) en JAVA
2ème méthode: implémentation de l’interface Runnable.
Il est préférable d'utiliser l'implémentation de Runnable car :
• elle permet à la classe d'hériter au besoin d'une classe mère
• elle permet une meilleure séparation des rôles
• elle évite des erreurs car il suffit simplement d'implémenter la méthode run()
Les processus (Thread) en JAVA
3ème méthode: utilisation d’une instance de type Runnable
Une autre écriture permet d’utiliser une instance de type Runnable
Les processus (Thread) en JAVA
Exemple d’utilisation de Thread en JAVA
[Link]
Le scénario d’échange de messages
Un premier processus ou Thread pour l’envoie de messages
similaire des deux cotés: Coté client et coté serveur:
57
Le scénario d’échange de messages
Un deuxième processus ou Thread pour la réception de messages
au niveau du client au niveau du serveur
58
Le scénario d’échange de messages
Une autre méthode consiste à utiliser deux classes permettant la
création de deux Thread, une Classe Reception pour un processus
de réception et une autre Classe pour Emission
59
Les sockets TCP - Multithreading
• L’avantage de ce modèle c’est qu’il permet un échange
continu, instantané et illimité de message sans aucun
scénario établi à l’avance.
• L'inconvénient du modèle décrit ci-avant est qu'il ne peut
traiter qu'une connexion en même temps.
Si plusieurs demandes de connexion arrivent simultanément,
une seule est acceptée, les autres sont mise en attente jusqu‘à
ce que le premier termine sa connexion.
Pour pouvoir traiter plusieurs connexions en même temps
(plusieurs clients), il faut que le serveur soit multithreadé.
60
Les sockets TCP - Multithreading
La création d’un serveur Multithreadé pourra être faite de plusieurs
manières, une solution simple consiste à un ensemble d’étapes :
1. Ecrire une boucle infinie au niveau du serveur pour l’acceptation
de connexions de la part de plusieurs clients.
2. Création d’un nouveau Thread sur le Serveur (le constructeur de
la classe serveur) en passant comme paramètre la socket
récupéré lors de l’acceptation de la connexion de la part du client.
3. Démarrage du Thread.
4. Redéfinition du constructeur en récupérant la socket dans la
propriété socket de la classe (d’autres paramètres : login)
5. Redéfinition de la méthode Run(), on pourra récupérer le flux
en entrée et le flux en sortie depuis et vers la socket service
client, ainsi que le lancement de deux thread pour la réception et
l’envoie de message librement entre un client et le serveur
61
Les sockets TCP - Multithreading
La création d’un serveur Multithreadé pourra être faite de plusieurs
manières, une solution simple consiste à un ensemble d’étapes :
1. Ecrire une boucle infinie pour l’acceptation de connexions de la
part de plusieurs clients.
2. Création d’un nouveau Thread sur le Serveur (le constructeur de
la classe serveur) en passant comme paramètre le socket
récupéré lors de l’acceptation de la connexion de la part du client.
3. Démarrage du Thread.
4. Redéfinition du constructeur en récupérant le socket dans la
propriété socket de la classe (d’autres paramètres : login)
5. Redéfinition de la méthode Run(), on pourra récupérer le flux
en entrée et le flux en sortie depuis et vers le socket service
client, ainsi que le lancement de deux thread pour la réception et
l’envoie de message librement entre un client et le serveur
62
Travaux Pratiques 2
I. Améliorer les deux programmes (Client et Serveur TCP en utilisant les
classes Socket et ServerSocket) du TP1 afin d’ajouter plus de flexibilité
en relation avec l’envoie de messages sans qu’il y a un scénario
d’échange de message préétablie à l’avance (Création de deux Threads
du coté client et deux autres du coté serveur).
II. Améliorer le code d’avantage afin de rendre le serveur Multithreadé de
manière à ce qu’il acceptera plusieurs connexions avec plusieurs
clients simultanément tout en échangeant librement les messages
avec chaque client (Le serveur demande à chacun de ses client de saisir
son login juste après l’établissement de la connexion). Utiliser une
Classe Emission et une autre Classe Reception implémentant
l’interface Runnable 63
//Boucle infinie
//Scénario pour échange du login
// Le serveur reçoit la connexion du client
// Lui demande de saisir un login
//Il récupère le login du client et lui envoie un message de Bienvenue
//Création d’un Thread (child) pour servir chaque client qui vient de se connecter
//Démarrage du Thread
64
65
//Traitement au sein du constructeur
//…
//Récupération d’un flux en entrée depuis le socket client
//Récupération d’un flux en sortie vers le socket client
//Création d’un Thread pour l’envoie
//Démarrage du Thread d’envoie
//Création d’un Thread pour la réception
//Démarrage du Thread de réception
66
67
Les sockets UDP
68
Les sockets UDP :
La classe DatagramSocket
69
Les sockets UDP :
La classe DatagramPacket
70
Utilisation des sockets UDP :
Envoie d’un Datagram
1. créer un DatagramPacket en spécifiant :
les données à envoyer
leur longuer
la machine réceptrice et le port
2. utiliser la méthode send(DatagramPacket) de DatagramSocket
pas d’arguments pour le constructeur de la classe
DatagramSocket (DatagramSocket socket = new DatgramSocket();)
car toutes les informations se trouvent dans le paquet envoyé
71
Utilisation des sockets UDP :
Envoie d’un Datagram
//Machine destinataire
InetAddress address = [Link](" [Link] ");
static final int PORT = 4562;
//Création du message à envoyer
String s = new String (" Message à envoyer");
int longueur = [Link]();
byte[] buffer = [Link]();
//Initialisation du paquet avec toutes les informations
DatagramPacket paquet;
paquet = new DatagramPacket(buffer,longueur, address,PORT);
//Création de la socket et envoi du paquet
DatagramSocket socket = new DatgramSocket();
[Link](paquet);....
72
Utilisation des sockets UDP :
Réception d’un Datagram
1. créer un DatagramSocket qui écoute sur le port de la machine du
destinataire
2. créer un DatagramPacket pour recevoir les paquets envoyés par le
serveur
• Dimensionner le buffer assez grand pour pouvoir recevoir le
paquet
3. utiliser la méthode receive(DatagramPacket) de DatagramSocket
Cette méthode est bloquante
73
Utilisation des sockets UDP :
Réception d’un Datagram
//Définir un buffer de réception
byte[] buffer = new byte[1024];
//On associe un paquet à un buffer vide pour la réception
DatagramPacket paquet;
paquet = new DatagramPacket(buffer , [Link]());
//On crée un socket pour écouter sur le port
DatagramSocket socket = new DatgramSocket(PORT);
while (true) {
//attente de réception
[Link](paquet );
//affichage du paquet reçu
String s = new String(buffer , 0 , [Link]());
[Link](“Paquet reçu : + s);
} 74
TP3
Réaliser un échange simple entre un Client et un serveur en
mode non connecté en utilisant le protocole UDP.
1. Le client se connectera au serveur tout en lui envoyant
un message contenant son login
2. Le serveur recevra le login et lui enverra un message de
Bienvenu
Transformer le serveur pour qu’il servira plusieurs clients
simultanément
75
//Création d’un socket du coté serveur sur le port 9632
//Préparation du paquet pour la réception
//Préparation du paquet pour l’envoie
//Réception du message du client
//Préparation du paquet pour l’envoie
//Envoie du paquet
//Lecture du message du client depuis l’entrée standard (clavier)
//Préparation du tableau d’octets (tampon ou buffer)
//…
//…
//
//Création du socket Client
//Préparation du paquet pour l’envoie
//Préparation du paquet pour la réception
//Envoie du message du Client (Login)
//Attente de la réception du message du serveur
//Affichage du message reçu de la part du serveur
//Affichage de l’adresse du serveur ainsi que le numéro du port
77
//Création et démarrage d’un thread sur le constructeur de la classe
//…
//Traitement du constructeur
//Redéfinition de la méthode run()
//Tout le traitement qui doit se faire du coté client avec chaque client qui va se connecter
//…
//…
//…
//…
//…
//…
//…
//…
//…
//…
//…
//…
//…
78
80
81