Ecole Nationale des Sciences Appliquées

EL JADIDA

Volume 1

Programmation Réseau et Distribuées

JAVAEE

Dr. Mohamed LACHGAR

lachgar.m@gmail.com

2019 - 2020
2
Contents

1 Les Sockets 5
1.1 Introduciton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Généralité sur les sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Mise en pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.1 Récupérer l’adresse IP . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.2 Socket côté serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.3 Socket côté client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 TP 1 : Socket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 Travail à rendre : chat multiutilisateurs avancé . . . . . . . . . . . . . . . 10

3
4 CONTENTS
Chapter 1

Les Sockets

1.1 Introduciton
Une socket est un mécanisme de communication permettant d’utiliser l’interface de
transport (TCP-UDP). Introduit dans Unix dans les années 80.
Un socket est un point de terminaison d’une communication bidirectionnelle, c’est-à-dire
entre un client et un serveur en cours d’exécution sur un réseau donné. Les deux sont liés
par un même numéro de port TCP de sorte que la couche puisse identifier la demande
de partage de données.
Une socket est un moyen de partager des données en réseau et elle se manipule comme
un fichier.
Principe de fonctionnement : 3 phases - illustration ci-dessous avec TCP :

1. le serveur crée une ”socket serveur” (associée à un port) et se met en attente.

2. le client se connecte à la socket serveur ; deux sockets sont alors crées : une ”socket
client”, côté client, et une ”socket service client” côté serveur. Ces sockets sont
connectées entre elles.

3. le client et le serveur communiquent par les sockets. L’interface est celle des fichiers
(read, write). La socket serveur peut accepter de nouvelles connexions

1.2 Généralité sur les sockets

Les sockets permettent de :

• Se connecter à une machine distante ;

• Recevoir et envoyer des données ;

• Fermer une connexion établie ;

• Attendre une connexion de l’extérieur ;

• Écouter les communications entrantes ;

• Utiliser un port.

Deux réalisations possibles du client-serveur avec sockets

5
6 CHAPTER 1. LES SOCKETS

• Mode connecté (protocole TCP)

– Ouverture d’une liaison, suite d’échanges, fermeture de la liaison;

– Le serveur préserve son état entre deux requêtes;
– Garanties de TCP : ordre, contrôle de flux, fiabilité;
– Adapté aux échanges ayant une certaine durée (plusieurs messages).

• Mode non connecté (protocole UDP)

– Les requêtes successives sont indépendantes;

– Pas de préservation de l’état entre les requêtes;
– Le client doit indiquer son adresse à chaque requête (pas de liaison perma-
nente);
– Pas de garanties particulières (UDP);
– Adapté aux échanges brefs (réponse en 1 message).

• Points communs

– Le client a l’initiative de la communication ; le serveur doit être à l’écoute;

– Le client doit connaître la référence du serveur [adresse IP, n° de port] (il peut
la trouver dans un annuaire si le serveur l’y a enregistrée au préalable, ou la
connaître par convention : n°s de port préafféctés);
– Le serveur peut servir plusieurs clients (1 thread unique ou 1 thread par client).

1.3 Mise en pratique

1.3.1 Récupérer l’adresse IP
Le package java.net de la plate-forme Java fournit une classe InetAddress qui nous permet
de récupérer et manipuler son adresse internet IP.

Les méthodes de la classe InetAdress

Cette classe n’a pas de constructeur, pour pouvoir avoir une instance de cette classe on
a besoin des méthodes de classe.

• getLocalHost() : elle retourne un objet qui contient l’adresse IP de la machine

locale.

• getByName(String nomDeMachine) : elle retourne un objet qui contient l’adresse

IP de la machine dont le nom est passé en paramètre.
1.3. MISE EN PRATIQUE 7

Exemple :

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

public static void main(String[] args) {
InetAddress adresseLocale = null;
InetAddress adresseServeur = null;
try {
adresseLocale = InetAddress.getLocalHost();
System.out.println("Mon adresse est : " + adresseLocale);
adresseServeur = InetAddress.getByName("www.google.com");
System.out.println("L'adresse de serveur google est : " +
adresseServeur);
} catch (UnknownHostException ex) {
Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
}
}
}

Résultat
Mon adresse est : DESKTOP-70FPU48/192.168.205.2
L'adresse de serveur google est : www.google.com/172.217.18.228

1.3.2 Socket côté 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, port) :
ServerSocket sersoc = new ServerSocket (port) ;

On obtiendra ensuite une ”socket” associée à cet objet, en utilisant la méthode accept :
Socket soc = sersoc.accept();

Puis la méthode getInputStream de la classe Socket permettra d’obtenir un flux de type

InputStream associé à cette socket :
InputStream flux = soc.getInputStream() ;

On pourra ensuite lire classiquement des informations sur ce flux, comme nous avons
appris à le faire précédemment. Par exemple, on pourra lire de simples lignes de texte,
en créant un objet de type BufferedReader :
BufferedReader lecteur = new BufferedReader (new InputStreamReader (flux)) ;

Chaque ligne sera lue par une instruction de la forme (message étant de type String) :
8 CHAPTER 1. LES SOCKETS

message = lecteur.readLine() ;

A titre indicatif, voici un programme très simple réalisant ces opérations :

import java.io.* ;
import java.net.* ;
//Lecture de "lignes de texte" par un serveur sur le port 1000
public class Serveur
{
public static void main (String args[]) throws IOException
{
int port = 1000 ;
ServerSocket sersoc = new ServerSocket (port) ;
System.out.println ("serveur active sur port " + port) ;
while (true)
{
Socket soc = sersoc.accept();
InputStream flux = soc.getInputStream ();
BufferedReader entree = new BufferedReader (new InputStreamReader
(flux));
String message = entree.readLine() ;
System.out.println ("message reçu sur le serveur = " + message) ;
}
}
}

1.3.3 Socket côté client

Pour pouvoir communiquer avec le serveur, le client créera un objet de type Socket,
associé à la fois à l’adresse IP du serveur (hote) et au numéro de port du service (port) :
Socket soc = new Socket (hote, port) ;

Pour ”émettre” sur cette socket, on lui associera un flux de type OutputStream par:
OutputStream flux = soc.getOutputStream() ;

Comme ici nous avons prévu que le serveur ”lise” des lignes de texte, nous construirons
sur cette socket un objet de type OutputStreamWriter :
OutputStreamWriter sortie = new OutputStreamWriter (flux) ;

sur lequel il nous suffira d’”écrire” les lignes voulues par des instructions telles que :
sortie.write (.....) ;

Voici un programme très simple se contentant d’envoyer une ligne de texte au serveur
précédent :
import java.net.* ;
import java.io.* ;
1.4. TP 1 : SOCKET 9

//Envoi d’une ligne de texte au serveur

public class Client
{
public static void main (String args[]) throws IOException
{
String hote = "127.0.0.1";
int port = 1000 ;
Socket soc = new Socket (hote, port);
OutputStream flux = soc.getOutputStream() ;
OutputStreamWriter sortie = new OutputStreamWriter (flux);
sortie.write("message envoye au serveur \n") ;
sortie.flush(); // pour forcer l'envoi de la ligne
}
}

Ici, le serveur affichera :

serveur active sur port 1000

message reçu sur le serveur = message envoyé au serveur

1.4 TP 1 : Socket
Exercice 1
Modifier les deux programmes précédents de telle sorte que le serveur envoi un accusé de
réception au client.

Exercice 2
Développer une application client/serveur. Le client transmet un nombre entier au
serveur, ensuite le serveur calcul son factoriel et retransmet le résultat au client.

Figure 1.1: Socket : Factoriel

Exercice 3
Réaliser une application permettant à deux programmes (un client et un serveur) de
discuter entre eux au tac’o’tac, c’est à dire que le client ne pourra pas envoyer des messages
successifs au serveur, ce sera un message chacun l’un après l’autre.
NB : Pour faire un programme permettant l’envoi de plusieurs messages simultanés, il
faudra utiliser les threads.
10 CHAPTER 1. LES SOCKETS

Figure 1.2: Socket : TAC ’o’ TAC

Exercice 4
Réaliser une application de chat multiutilisateurs :

Figure 1.3: Socket : chat multiutilisateurs

1.5 Travail à rendre : chat multiutilisateurs avancé

Créer une application permettant un dialogue entre des utilisateurs d’un réseau .Chaque
utilisateur doit pouvoir créer, se connecter ou se déconnecter dynamiquement de groupes
de dialogue, pour autant qu’il en soit autorisé.

Cette application devra au moins permettre un dialogue entre deux utilisateurs, entre
un utilisateur et un groupe, entre un utilisateur et des groupes, entre un utilisateur et tous
les groupes, entre un utilisateur et tous les groupes sauf certains (utilisateurs ou groupes).

Elle devra aussi permettre facilement un échange en aparté, ainsi que la participation
simultanée à plusieurs groupes de discussion.
1.5. TRAVAIL À RENDRE : CHAT MULTIUTILISATEURS AVANCÉ 11

Elle offrira un mécanisme permettant de savoir qui est présent sur le réseau, sa disponi-
bilité. L’entrée dans un groupe de discussion sera signalée aux autres membres de ce
groupe.

Finalement un journal des échanges sera constitué. Il permettra à un nouveau con-

necté de connaître l’historique de la discussion.