applications distribués en réseaux local:
1: les sockets
Dr. Laroum .T
[email protected]
1
Définitions : adresse IP
• Une application distribué est une application client-serveur.
• Développer une application distribuée ===> créer une classe serveur et une classe client.
• Le serveur et les clients s’exécutent dans des machines différentes et sont manipulés par
plusieurs utilisateurs simultanément.
• Chaque machine dans le réseau local possède une addresse IP.
• L’adresse IP est indispensable pour la communication entre les clients et le serveur.
Réseau local
2
Définitions : adresse IP
• Chaque machine possède également une adresse interne qui est 127.0.0.1.
• Lorsqu'un programme utilise cette adresse réseau, il utilise la machine sur laquelle il
fonctionne.
• L'intérêt de cette adresse est qu'elle ne nécessite pas de carte réseau. On peut donc
tester des programmes réseau sans être connecté à un réseau.
• Une autre façon de désigner la machine locale est d'utiliser le nom localhost.
3
Définitions : adresse IP
pour afficher l’adresse IP on écrit:
import java.net.*;
public class netadresse{
public static void main (String arg[])
{
Try
{
InetAddress adresse=InetAddress.LocalHost();
System.out.println("IP : "+ adresse.getHostAddress());
System.out.println("nom : "+ adresse.getHostName());
} catch (UnknownHostException e){System.out.println ("Erreur : "+e);}
}
}
4
Remarque:
1. Dans les application réseau nous devons importer le package java.net.*
2. Dans les applications réseaux nous devons gérer les exceptions.
5
Connexion entre client et serveur:
• La finalité d'un réseau est de permettre à deux machines de se connecter et ainsi de se «
parler ».
• Une fois que les deux machines se sont trouvées l'une l'autre, elles peuvent entamer une
conversation bi-directionnelle.
• Mais comment trouvent-elles l'autre ?
6
Connexion entre client et serveur:
• Tout se passe à peu près comme lorsqu'on est perdu l’université : une des machines doit
attendre l'appel de l'autre sans bouger : « Hé, où êtes-vous ? »
• La machine qui attend est appelée serveur, celle qui cherche client.
serveur
client 7
Définitions : client et serveur:
• Le rôle du serveur est d'être en attente d'une demande de connexion, tandis que Le rôle
du client est de tenter d'établir une connexion avec un serveur.
• Une fois la connexion établie, il ne reste qu'à utiliser les commandes d'E/S (on peut
traiter cette connexion comme une lecture ou une écriture dans un fichier.) c'est un des
aspects agréables des fonctions de Java en réseau.
8
Les Entrées Sorties en java:
• Un programme a souvent besoin d'échanger des informations, que ce soit pour recevoir
des données d'une source ou pour envoyer des données vers un destinataire.
• On appelle ces information les entrées/sorties.
• En java, toutes les entrées/sorties sont gérés par des flux (= streams):
• E/S avec l’écran et el clavier (flux standard).
• E/S Avec un fichier (disque dur).
• E/S Avec un socket (dans le réseau).
• Ces informations (flux) peut être des caractères ou des octets.
9
Les Entrées Sorties en java:
• Plusieurs classes java sont utilisées pour gérer les entrées/sorties:
• Ils sont définies dans le package java.io.*;
Pour écrire des données:
1. De différents types
2. De type String
Pour lire des données:
1. De différents types
2. De type String
10
Définitions : numéro du port:
• Une adresse IP n'est pas suffisante pour identifier un serveur, (plusieurs services sur la
même machine).
• Si vous donnez rendez-vous à quelqu'un à l’université, l'adresse IP représentera le
département et le port sera le numéro de la salle.
• Le port n'est pas un emplacement physique dans la machine, mais une abstraction de
programmation.
Le client Cherche le serveur par
l’adresse IP serveur
+
numéro de port
client 11
Définitions : numéro du port:
• les numéros de port représentent un deuxième niveau d'adressage pour demander le
service associé à ce numéro de port.
• Les services système réservent les numéros de ports 1 à 1024, il ne faut donc pas les
utiliser.
Le client Cherche le serveur par
l’adresse IP
+
numéro de port
12
Architecture du client:
• Le programme client possède l’architecture suivante:
1. établir la connexion avec le service S1 de la machine serveur
2. si ok alors :
3. tant que ce n'est pas fini (boucle)
• préparer une demande et l'émettre vers le serveur.
•attendre et récupérer la réponse puis la traiter
4. Fin tant que
5. Fin si
13
Architecture du serveur :
• Le programme serveur possède l’architecture suivante:
1. ouvrir le service sur la machine locale
2. tant que le service est ouvert
• se mettre à l'écoute des demandes de connexion.
• lorsqu'il y a une demande de connexion, la faire traiter (attendre des
messages et envoyer les réponses).
3. Fin tant que
4. Fin si
14
Socket et serverSocket:
• La classe de base dans la communication réseau est la classe socket.
• Le socket peut être représenté par un téléphone.
• Le socket contient un emplacement pour parler (l’objet out) et un emplacement pour
écouter (l’objet in ).
• Pour que 2 personnes puissent communiquer, chacun doit avoir un téléphone (un
socket).
in
in
Out
Out
15
Socket et serverSocket:
• Une connexion réseau entre deux machines est vue comme un canal susceptible de
transmettre de l’information.
• Un socket est une abstraction de programmation (une classe java) représentant les
extrémités d'une connexion entre deux machines: Un socket sur chaque machine.
• On peut imaginer un câble virtuel reliant les deux machines, chaque extrémité enfichée
dans un socket.
16
Socket coté client:
• Pour pouvoir communiquer avec le serveur, le client créera un objet de type Socket,
associé à la fois à l’adresse IP du serveur (hôte) et au numéro de port du service (port) :
Socket s = new Socket (adresse_IP, port) ;
• Il faut gérer les exceptions car ce constructeur génère une exception dans différents cas :
mauvaise adresse, mauvais port, demande refusée…
• Si la connexion est bien établie, le client pourra envoyer et recevoir des données sur ce
socket.
17
La communication se fait entre
client serveur
les sockets
ServerSocket
Socket Socket Port 3000
18
Socket coté serveur:
• Pour que le serveur soit prêt à recevoir des informations, on devra créer un objet de type
ServerSocket, associé au numéro de port choisi (ici, 3000) :
ServerSocket ss = new ServerSocket (3000) ;
• Cette classe est destinée à la gestion des sockets coté serveur, son constructeur prend
comme paramètre le numéro de port à écouter.
• Lorsqu'on crée un ServerSocket, on ne lui assigne qu'un numéro de port. Il n'est pas
nécessaire de lui assigner une adresse IP parce qu'il réside toujours sur la machine qu'il
représente.
• Le socket client ne communique pas avec le serversocket mais toujours avec un socket …
donc il faut créer un socket au niveau du server pour communiquer avec.
19
La communication se fait entre
client serveur
les sockets
ServerSocket
Socket Socket Port 3000
20
Socket coté serveur:
Acceptation des demande de connexion des clients:
• Lorsqu’un client fait une demande de connexion sur le port d'écoute du service, celui-ci
l'accepte avec la méthode :
Socket socket_du_Serveur= ss .accept(); // cette méthode est bloquante
• Cette méthode crée une instance de Socket (qui peut fournir des informations sur le
client): c'est le socket de service, à travers laquelle le service sera rendu.
• La méthode peut générer une exception.
• A ce moment là nous avons des sockets sur les deux extrémités de la connexion, il est
possible maintenant d’échanger de l’information.
• Pour gérer plusieurs client on utilise les threads.
21
Socket coté serveur:
Enchainement de l’exécution :
22
Lire et écrire des String dans les socket :
• Pour envoyer/recevoir des String à partir du socket on utilise les objets :
• BufferedReader in ; //pour lire.
import java.io.*
• PrintWriter out; //pour écrire.
in = new BufferedReader( new InputStreamReader( socket.getInputStream()));
out= new PrintWriter (socket.getOutputStream(),true);
• si on veux envoyer un message on écrit : out.println("bonjour") ;
• si on veut lire un message, on écrit : String s= in.readLine() ;
• ces deux opération peuvent générer des exceptions.
• pour fermer le socket ou le serverSocket on utilise la méthode close() ; qui génère aussi
une exception.
23
On peut également utiliser:
• Pour envoyer/recevoir de données de divers types à partir du socket on utilise les objets :
• DataInputStream in ; //pour lire.
import java.io.*
• DataOutputStream out; //pour écrire.
DataInputStream in = new DataInputStream(socket.getInputStream());
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
• si on veux envoyer un message on écrit : out.writeUTF("bonjour") ;
• si on veut lire un message, on écrit : String s= in.readUTF () ;
• Si on envoyer un nombre int, on écrit: out.writeInt(45);
• Si on veut lire un nombre int on écrit: int x=in.readInt();
24
La classe client:
public class client {
Socket socket;
int port=3000;
PrintWriter out;
BufferedReader in;
public client() {
try {
socket=new Socket("localhost",port);
out= new PrintWriter (socket.getOutputStream(),true);
in = new BufferedReader( new InputStreamReader( socket.getInputStream()));
out.println(" hello serveur");
} catch (Exception e) {e.printStackTrace();}
}
}
public static void main(String[] args) {
new client();
}
} 25
La classe serveur :
public class serveur {
Socket socket;
int port=3000;
ServerSocket ss;
BufferedReader in;
PrintWriter out;
public serveur() {
try {
ss=new ServerSocket(port);
socket=ss.accept();
in = new BufferedReader( new InputStreamReader( socket.getInputStream()));
out= new PrintWriter (socket.getOutputStream(),true);
String message=in.readLine();
System.out.println("message du client: "+message);
} catch (Exception e) {e.printStackTrace();}
}
public static void main(String[] args) {
new serveur();
}
} 26
La classe client en utilisant: DataInputStream:
public class client {
int port=3000;
DataInputStream in;
DataOutputStream out;
Socket s;
public client() {
// TODO Auto-generated constructor stub
try {
s=new Socket("localhost",port);
in=new DataInputStream(s.getInputStream());
out=new DataOutputStream(s.getOutputStream());
out.writeUTF("hello server ...");
int taille=in.readInt();
System.out.println("reponse du serveur: taille="+taille);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new client();
}
}
27
La classe serveur en utilisant DataInputStream:
public class serveur {
int port=3000;
DataInputStream in;
DataOutputStream out;
Socket s;
ServerSocket ss;
public serveur() {
try {
ss=new ServerSocket(port);
System.out.println("server en attente ....");
s=ss.accept();
in=new DataInputStream(s.getInputStream());
out=new DataOutputStream(s.getOutputStream());
System.out.println("un client est arrivé!");
String msg=in.readUTF();
System.out.println("serveur: j'ai reçu le message:"+msg);;
out.writeInt(msg.length());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new serveur();
}
} 28
zzz
client serveur
Envoyer message
Lire message
29
Fin
30
