Rapport Sockets en Java

Master Spécialisé
Qualité du Logiciel
Rapport de projet
Sockets en Java
Réalisé Par : Soukaina NAJIHI
Meryem ABOUNASR
Soukaina BOUJADI
Encadré Par : Mr. ELANSARI
Année Universitaire 2013-2014

Remerciement
Nous souhaitons adresser nos remerciements
les plus sincères à notre professeur M
ELANSARI qui nous a toujours aidé et apporté
ses directives et remarques pertinentes .Nous le
remercions encore pour l’occasion qu’il nous a
donné pour affronter ce monde merveille
d’Unix.
Année Universitaire 2013-2014 2

Table des matières
Remerciement.............................................................................................................................. 2
Table des matières ....................................................................................................................... 3
CHAPITRE 1: Introduction au sockets ................................................................................... 5
1.1 Problème ....................................................................................................................................... 6
1.2 Comment ? -> Interface TCP/IP APPLICATION .......................................................................... 6
1.3 Les adresses IP en Java .................................................................................................................. 8
CHAPITRE 2: Qu'est-ce qu'un socket ? ........................................................................ 10
2.1 Définition du socket .................................................................................................................... 11
2.2 Sockets TCP/UDP ......................................................................................................................... 12
CHAPITRE 3 : Socket en mode connecté ..................................................................... 13
3.1 Pour mieux comprendre : exemple appel téléphonique ............................................................ 14
3.1.1 accueil téléphonique d’une entreprise ................................................................................ 14
3.1.2 Comme le téléphone ........................................................................................................... 14
3.1.3 Installation du téléphone .................................................................................................... 15
3.1.4 La conversation téléphonique .............................................................................................. 16
3.1.5 Raccrocher le téléphone ....................................................................................................... 16
3.1.6 Overview ............................................................................................................................... 17
3.2 Socket TCP - Déroulement ......................................................................................................... 17
3.3 Implémentation : Socket TCP ...................................................................................................... 18
3.4 Gestion du parallélisme sur le serveur ........................................................................................ 23
3.4.1 Serveur Multi-Threads ......................................................................................................... 23
3.4.2 Déroulement en multi-thread .............................................................................................. 24
3.4.3 Un serveur TCP/IP multiclients ........................................................................................... 25
3.4.4 Implémentation d’un serveur multi-thread ......................................................................... 26
CHAPITRE 4 : Socket en mode non connecté .............................................................. 31
4.1 La classe DatagramPacket ........................................................................................................... 32
4.2 La classe DatagramSocket .......................................................................................................... 34
4.3 Socket UDP:Déroulement ............................................................................................................ 36
4.4 Implémentation : Socket UDP ..................................................................................................... 37
CHAPITRE 5 : Comparaison socket JAVA ET C ............................................................ 40

5.1 En mode Connecté ...................................................................................................................... 41
5.1.1 Côté serveur ......................................................................................................................... 41
5.1.2 Client ..................................................................................................................................... 43
5.1.3 Récpitulatif ........................................................................................................................... 43
5.2 En mode déconnecté ................................................................................................................... 45
5.2.1 Côté serveur et côté Client ................................................................................................... 45
5.2.2 Récapitulatif ......................................................................................................................... 45

CHAPITRE 1:
Introduction au sockets

1.1 Problème
La communication via un LAN ou WAN possède de multiples applications :
* client/serveur Internet,
* commande à distance de différents équipements : robot industriel, robot de
chirurgie, commande d’équipement, …
* gestion d’appareils de mesure via un LAN,
Prenons un exemple : pilotage d’une installation de chauffage à distance.
On souhaite gérer une installation de chauffage à distance soit par :
a) un ordinateur ;
b) un téléphone portable GSM ;
1.2 Comment ? -> Interface TCP/IP
APPLICATION
Après avoir étudié les protocoles TCP/IP, il reste à voir le problème de
l’interface entre les programmes d’application et les logiciels de la pile
TCP/IP, il existe différentes solutions pour résoudre ce problème parmi eux
on trouve les sockets.

Le schéma ci-dessous permet de faire la correspondance entre les couches
de la modélisation contemporaine et celles de la représentation
macroscopique d'un système d'exploitation.
Le logiciel correspondant aux protocoles allant de la couche physique jusqu'à
la couche transport fait partie du sous-système réseau du noyau du système
d'exploitation. Le programme utilisateur est lancé à partir de la couche Shell
et est exécuté au niveau application.
L'utilisation de sockets revient à ouvrir un canal de communication entre la
couche application et la couche transport.
Les sockets servent à communiquer entre deux hôtes appelés Client /
Serveur à l'aide d'une adresse IP et d'un port ; ces sockets permettront de
gérer des flux entrant et sortant afin d'assurer une communication entre les
deux (le client et le serveur), soit de manière fiable à l'aide du protocole
TCP/IP, soit non fiable mais plus rapide avec le protocole UDP.
Voici ce qu'on peut réaliser à l'aide des sockets :
 des jeux en ligne ;
 des systèmes distribués ;
 des espaces messengers comme MSN Messenger, Yahoo Messenger, … ;
 des applications comme BitComet permettant de gérer les fichiers
.torrent que vous connaissez ;
 et bien d'autres choses.

1.3 Les adresses IP en Java
 Représentés par la classe java.net.InetAddress
Contient 2 champs :
 hostname : Stocke le nom de l’hôte (ex: www.monsite.com)
 address : Stocke l’adresse IP de l’hôte
 Pas de constructeurs publics.
 Pour créer une InetAddress, il faut utiliser une des méthodes suivantes
:
public static InetAddress getByName(String nom_hote)
public static InetAddress [] getAllByName(String nom_hote)
public static InetAddress getLocalHost()
 public static InetAddress getByName (String nom_hote)
Cette méthode utilise le DNS pour renvoyer une instance de la classe
InetAddress contenant l’adresse IP de la machine dont le nom est passé en
paramètre
En cas d’erreur, lève l’exception UnknownHostException
Exemple :
InetAddress adr = InetAddress.getbyName(“www.site.com“);
 public static InetAddress getByName [] (String nom_hote)
 Renvoie toutes les adresses IP de la machine (dont le nom est passé
en paramètre)

 En cas d’erreur, lève l’exception UnknownHostException
 public static InetAddress getLocalHost ()
 Renvoie une instance de la classe InetAddress
 contenant l’adresse IP de la machine locale
 En cas d’erreur, lève l’exception UnknownHostException
Équivalent à :
 getByName(null) , getByName("localhost")
 public String getHostName ()
 Renvoie la chaine de caractères contenant le nom de la machine
locale
 Renvoie l’adresse IP de la machine si elle n’a pas de nom
 public byte [] getAddress ()
 Renvoie l’adresse IP de la machine locale sous forme de tableau
d’octets rangés selon l’ordre réseau . Le premier octet contient
l’octet de poids fort de l’adresse

CHAPITRE 2:
Qu'est-ce qu'un socket ?

2.1 Définition du socket
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.
Un serveur fonctionne sur une machine bien définie et est lié à un numéro de
port spécifique. Le serveur se met simplement à l'écoute d'un client, qui
demande une connexion.
Il existe au moins deux grands modes de communication :
 par paquet (datagram) : dans ce mode on est pas connecté
 en flux (stream) : dans ce mode on est connecté

2.2 Sockets TCP/UDP
Dans le mode flux (Mode Connecté)
- les informations sont reçues dans l’ordre exact de leur émission
- il n’y a pas de perte .
- 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).
- inconvénient : nécessite l’établissement d’une connexion et
consomme donc des ressources pour sa gestion
Dans le mode paquet (Mode non connecté)
- il n’existe pas d’ordre dans la délivrance des paquets
- un paquet posté en premier peut arriver en dernier
- il n’existe pas non plus de fiabilité
- un paquet envoyé peut être perdu
- 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
permanente).
- Pas de garanties particulières.
- Adapté aux échanges brefs (réponse en 1 message).
- intérêt : souple et léger...

CHAPITRE 3 :
Socket en mode connecté

3.1 Pour mieux comprendre : exemple appel
téléphonique
3.1.1 accueil téléphonique d’une entreprise
Les entreprises disposent généralement d’un standard téléphonique chargé
d’aiguiller les appels vers le bon destinataire :
3.1.2 Comme le téléphone
Les sockets sont la méthode BSD (inventée par l’Université de Berkeley) pour
réaliser des communications entre processus (IPC, Inter Processus
Communications). C’est-à-dire qu’un socket permet à un processus de
communiquer avec un autre situé à distance sur le même LAN, tout comme
une ligne de téléphone permet à deux personnes de se parler. L’analogie avec
le réseau téléphonique est excellente et nous allons l’utiliser au long de ce
petit guide.

3.1.3 Installation du téléphone
Pour recevoir des appels téléphoniques, il nous faut installer le téléphone. De
même nous devons créer un socket qui attendra des connexions. Cela se fait
en plusieurs étapes :
a) Installation d’une nouvelle ligne ; l’instanciation de la classe
ServerSocket, qui met en oeuvre une sorte de port que les serveurs
peuvent utiliser pour écouter et accepter les connexions des clients.
b) Après la création, nous devons indiquer à notre socket quel port
écouter, exactement comme le numéro de téléphone que vous obtenez,
vous permettra de recevoir des appels. C’est le rôle du constructeur de
la classe ServerSocket qui « attache » le socket serveur à un port ; Ce
qui nous donne :
ServerSocket socketserver = new ServerSocket(numero_port);
c) Pendant le traitement d’une connexion. Nous avons la possibilité
d’indiquer le nombre maximum de requêtes possibles. Il existe deux
autres constructeurs ; l'un a deux paramètres, le premier est bien sûr
le numéro de port et le nombre total de connexion simultanées
acceptées, voyez :
ServerSocket socketserver = new ServerSocket(numer_port,nbr_max);
nbr_max est le nombre maximal de connexions traitées
simultanément. Par exemple au-delà de cinq tentatives de connexion
consécutives autorisées, les connexions sont refusées.
Pour le second constructeur il suffit de spécifier l'adresse locale du
serveur.
ServerSocket socketserver = new
ServerSocket(numer_port,nbr_max,adresse_locale);
d) Après la création de socket permettant de recevoir des appels, il faut
répondre aux demandes de connexion. C’est le rôle de la fonction

accept (), qui est analogue à l’action de décrocher le combiné lorsque
le téléphone sonne. Cette fonction accept () va retourner un nouvel
socket, qui sera connecté à l’appelant.
Socket socketduserveur = socketserver.accept();
e) Vous savez maintenant comment créer un socket qui accepte les
demandes de connexion. Mais comment l’appeler ? Pour passer un
appel téléphonique, vous devez avoir le téléphone. Eh bien, vous allez
utiliser la fonction socket(), exactement comme pour l’établissement
d’un socket qui doit attendre les connexions. Mais vous devez lui
indiquez le nom de la machine sur laquelle le serveur est en exécution
et le numéro de port sur lequel il écoute.
Socket socket = new Socket(param1, param2)
f) Il faut alors écrire une fonction rassemblant les appels systèmes ci-dessus.
Cette fonction appelle un port particulier d’une certaine
machine, qu’on lui passe en paramètre.
3.1.4 La conversation téléphonique
Maintenant que vous disposez d’une connexion entre deux sockets, vous
allez vouloir échanger des données entre les 2 machines mises en jeu (ou la
même, le réseau étant transparent, il peut s’agir de processus sur le même
système, peu importe !). Et là, vous allez voir la magie de la chose : on utilise
les fonctions read () et write ().
3.1.5 Raccrocher le téléphone
De la même façon que vous devez raccrocher le combiné téléphonique
lorsque vous avez terminé votre conversation, vous devez couper la
connexion entre les deux sockets lorsque tout est fini. On utilise pour cela la
fonction close ().

3.1.6 Overview
3.2 Socket TCP - Déroulement

3.3 Implémentation : Socket TCP
Le client envoie au serveur un nombre entier, le serveur le multiple par 5 et
renvoie le résultat au client
 Serveur.java : Exemple d’un serveur simple :

import java.io.*;
import java.net.*;
public class Serveur {
public static void main(String[] args) {
try {
ServerSocket ss=new ServerSocket(1234);
System.out.println("j'attend la connexion d'un client");
Socket clientSocket=ss.accept();
System.out.println("Nouveau client connecté");
System.out.println ("Génération de objet InptStream et
OutputStream de la socket");
InputStream is=clientSocket.getInputStream();
OutputStream os=clientSocket.getOutputStream();
System.out.println("J'attend un nombre (1 octet)!");
int nb=is.read();
System.out.println("J'envoie la réponse");
os.write(nb*5);
System.out.println("Déconnexion du client");
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}}}
1) Client.java : Exemple d’un client simple

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Client {
try {
System.out.println("Créer une connexion au serveur:");
Socket clientSocket=new Socket("localhost", 123);
System.out.println("Génération de objet InptStream et
OutputStream de la socket");
InputStream is=clientSocket.getInputStream();
OutputStream os=clientSocket.getOutputStream();
System.out.println("Lire un nombre au clavier NB=");
Scanner clavier=new Scanner(System.in);
int nb=clavier.nextInt();
System.out.println("Envoyer le nombre "+nb+" au
serveur");
os.write(nb);
System.out.println("Attendre la réponse du serveur:");
int rep=is.read();
System.out.println("La réponse est :"+rep);
} catch (Exception e) {
e.printStackTrace();
}}}

 Lancement du serveur :
Après le lancement du serveur la console affiche le message suivant
J'attend la connexion d’un client
Console Serveur
 Lancement du client :
J’attend la connexion d’un client
Nouveau client connecté
Génération de objet InptStream et OutputStream de la socket
J’attend un nombre (1 octet) !
Console Serveur
Créer une connexion au serveur:
Lire un nombre au clavier NB=_
Console Client
 Saisir un nombre par le client et l’envoyer au serveur :

J’attend la connexion d’un client
Nouveau client connecté
J’attend un nombre (1 octet) !
J’envoie la réponse
Déconnexion du client
Console Serveur
Créer une connexion au serveur:
Lire un nombre au clavier NB=12
Envoyer le nombre 12 au serveur
Attendre la réponse du serveur
La réponse est : 60
Console Client

3.4 Gestion du parallélisme sur le serveur
La communication ne doit pas rester bloquée pour un client
D’après ce qu’on a vu dans jusqu’à maintenant, un seul processus serveur :
S’il y a des clients multiples, ils sont traités en séquence (les requêtes sont
conservées dans une file d’attente associée à la socket serveur)
La longueur max de cette file d’attente peut être spécifiée lors
de la création de la socket serveur. Valeur par défaut : 50.
Mais si l ' on veut que plus que deux puissent communiquer entre eux à
la fois , comment faire ? D'où la nécessité d'utiliser les Threads.
3.4.1 Serveur Multi-Threads
Pour qu’un serveur puisse communiquer avec plusieurs client en même
temps, il faut que:
- Le serveur puisse attendre une connexion à tout moment.
- Pour chaque connexion, il faut créer un nouveau thread associé à la
socket du client connecté (donc à l’exécution de accept()), puis
attendre à nouveau une nouvelle connexion
- Le thread créé doit s’occuper des opérations d’entrées-sorties
(read/write) pour communiquer avec le client indépendamment des
autres activités du serveur (Une socket service client différente est
créé pour chaque client).
- Le thread veilleur se remet ensuite en attente

Connections multithread
3.4.2 Déroulement en multi-thread

3.4.3 Un serveur TCP/IP multiclients
class Service implements Runnable
{
private Socket s;
Service (Socket _s)
{s=_s; }
void run()
{
//bla bla bla
s.close();
}
}
while (true)
{
accepter la connexion d’un nouveau
client et créer une socket service client;
créer un thread pour interagir avec ce client
sur la nouvelle socket service client ;
}
....
ServerSocket socketAttente;
SocketAttente = new ServerSocket(7777);
while (true) {
Socket socket=socketAttente.accept();
// Connexion établie
// La communication est désormais possible
Service s=new Service(socket);
Thread t = new Thread(s);
t.start();
}
SocketAttente.close();
....

le serveur utilise une classe Service implémentant l’interface
Runnable(thread) pour gérer les échanges de données en tâche de fond.
C’est ce thread qui réalise le service demandé
3.4.4 Implémentation d’un serveur multi-thread
Le serveur se compose au minimum par deux classes :
 ServeurMultiThread.java : serveur principal :

import java.io.*;
import java.net.*;
public class ServeurMultiThread extends Thread {
int nbClients=0; // pour compter le nombre de clients connectés
public void run(){
try {
System.out.println("J'attend une connexion");
ServerSocket ss=new ServerSocket(4321);
while(true){
Socket s=ss.accept();
++nbClients;
new ServiceClient(s,nbClients).start();
}
} catch (IOException e) {e.printStackTrace();}
} // Fin de la méthode run
new ServeurMultiThread().start();
}}

 La classe qui gère les entrées-sorties : ServiceClient.java :
import java.io.*;
import java.net.*;
public class ServiceClient extends Thread {
Socket client;
int numero;
public ServiceClient(Socket s,int num){client=s;numero=num; }
public void run(){
try {
BufferedReader in=new BufferedReader(
new InputStreamReader(client.getInputStream()));
PrintWriter out=new PrintWriter(client.getOutputStream(),true);
System.out.println("Client Num "+numero);
out.println("Vous etes le client num "+numero);
while(true){
String s=in.readLine();
out.println("Votre commande contient "+ s.length()+" caractères");
}
}
catch (IOException e) {
e.printStackTrace();}
}
}

 Lancement du serveur multithreads :
Après le lancement du serveur la console affiche le message suivant
J'attend une connexion
Console Serveur
 Lancement des client :
Client Num 1
Client Num 2
Vous etes le client num 1
Console Serveur
Client 1 Client 2

 Communication entre les clients et le serveur :
Client Num 1
Client Num 2
Soukaina
Votre commande contient 8
caractères
Meryem
caractères
Console Serveur
MQL
caractères
UNIX
caractères
Client 1 Client 2

CHAPITRE 4 :
Socket en mode non connecté

Dans java.net on trouve les classes :
•DatagramSocket
•DatagramPacket
4.1 La classe DatagramPacket
Cette classe permet de créer des objets qui contiendront les données
envoyées ou reçues ainsi que l'adresse de destination ou de provenance du
datagramme.
Deux constructeurs sont disponibles, un pour les paquets à recevoir, l'autre
pour les paquets à envoyer.
 public DatagramPacket(byte buffer[], int taille)
Construit un objet pour recevoir un datagramme. Le
paramètre buffer correspond à la zone où doit être stocké le datagramme
reçu et le paramètre taille correspond à la taille maximale des datagrammes
à recevoir.
byte[]buffer : tableau d’octets permettant la réception des données
ATTENTION : Si la taille du tableau est insuffisante, les données seront
tronquées
Exemple
byte[] tampon = new byte[1024];
DatagramPacket datagramme = new DatagramPacket(tampon,
tampon.length);

 public DatagramPacket(byte buffer[], int taille, InetAddress adresse, int
port)
Construit un objet pour envoyer un datagramme. Le
paramètre buffer correspond à la zone où est stocké le datagramme à
envoyer, le paramètre taille correspond à la taille du datagramme à
envoyer, adresse correspond à l'adresse de la machine à qui envoyer le
datagramme et port sur quel port UDP.
Exemple
String message = “coucou !!! “ ;
byte[] tampon = message.getBytes();
InetAddress adresse=
InetAddress.getByName(“moncorrepsondant.fr“);
DatagramPacket datagramme = new DatagramPacket(tampon,
tampon.length, adresse, 45848);
Des méthodes sont disponibles pour manipuler de tels objets :
 public synchronized InetAddress getAddress ()
Retourne l'adresse stockée dans le paquet.
 public synchronized int getPort ()
Retourne le port stocké dans le paquet.
 public synchronized byte[] getData ()
Retourne les données stockées dans le paquet.
 public synchronized int getLength ()
Retourne la taille des données stockées dans le paquet.
 public synchronized void setAddress(InetAddress iaddr)
Modifie ou affecte l'adresse de destination.
 public synchronized void setPort(int iport)

Modifie ou affecte le port de destination.
 public synchronized void setData(byte ibuf[])
Modifie ou affecte la référence de la zone contenant les données.
 public synchronized void setLength(int ilength)
Modifie ou affecte la taille de la zone contenant les données.
4.2 La classe DatagramSocket
Cette classe permet de créer des sockets UDP qui permettent d'envoyer et de
recevoir des datagrammes UDP.
Avant toute communication en mode UDP il est nécessaire de créer
une socket aussi bien du coté client que du coté serveur. Pour cela Java
propose trois constructeurs :
 public DatagramSocket () throws SocketException
Crée un objet de type socket et l'attache à un port disponible de la machine
locale. Ce constructeur doit être utilisé dans les clients pour lesquels le port
d'attachement n'a pas besoin d'être connu.
Remarque : pas d’arguments pour le constructeur car toutes les
informations se trouvent dans le paquet envoyé.
 public DatagramSocket (int port) throws SocketException
Crée un objet de type socket et l'attache au port UDP local passé en
paramètre. En particulier, ce constructeur doit être utilisé dans les serveurs
pour lesquels le port d'attachement a besoin d'être fixé préalablement afin
qu'il soit connu des clients.
 public DatagramSocket(int port, InetAddress laddr) throws
SocketException
Crée un objet de type socket, l'attache au port UDP local passé en paramètre
et à une adresse spécifique de la machine locale. Ce constructeur n'est utile
que si la machine locale dispose de plusieurs adresses Internet.

Une fois le socket (objet de type DatagramSocket) créée et attachée à un
port particulier de la machine locale, il est possible d'envoyer et de recevoir
des datagrammes, via cette socket, au moyen des méthodes suivantes :
 public void send(DatagramPacket data) throws IOException
Permet d'envoyer les données contenues dans la variable data vers la
machine et le port dont les valeurs ont été préalablement spécifiées dans la
variable data.
 public synchronized void receive(DatagramPacket data) throws
IOException
Permet de recevoir un datagramme qui sera stocké dans data. Après
appel, data contient les données reçues, leur taille, l'adresse de l'envoyeur
ainsi que son port d'attachement. Cette méthode est bloquante tant qu'il n'y
a rien à recevoir. Si le message est trop long pour être stocké, celui-ci est
tronqué, et le reste est perdu. Il n'est donc pas possible de recevoir des
messages dont on ne connait pas préalablement la taille.
 public void close() throws IOException
Même si Java ferme les DatagramSocket à la fin du programme (ou via le
Garbage collect), il est DE BON USAGE de fermer EXPLICITEMENT les
DatagramSockets via la méthode close une fois qu’ils ne sont plus utiles.

4.3 Socket UDP:Déroulement
 Un schéma récapitulatif

4.4 Implémentation : Socket UDP
 Server.java
import java.net.*;
public class Server {
public static void main(String []args) {
try {
DatagramSocket s = new DatagramSocket(5678);
byte []data = new byte[100];
System.out.println("J'attend un Client");
DatagramPacket paquet = new DatagramPacket(data,data.length);
while (true) {
s.receive(paquet);
String st = new String(paquet.getData(),0,paquet.getLength());
System.out.print("J'ai reçu ["+st+"]");
System.out.println(" depuis la machine "+" "+
paquet.getAddress().getHostName()+" port :"+
paquet.getPort());
}} catch(Exception ex) {
ex.printStackTrace();
System.exit(1);
}}}

 Client.java
import java.net.*;
public class Client {
public static void main(String []args) {
try {
DatagramSocket s = new DatagramSocket();
byte []data = args[0].getBytes();
InetSocketAddress sa = new InetSocketAddress("localhost",5678);
System.out.println("le paquet est créé !");
DatagramPacket paquet = new DatagramPacket(data,data.length,sa);
System.out.println("le paquet est envoyé");
s.send(paquet);
} catch(Exception ex) {
ex.printStackTrace();
System.exit(1);
}}}

 Lancement du serveur :
J’attend un client
 Lancement du client :
En passant une chaine de caractère ‘Abounasr Najihi Boujadi’
J’attend un client
J'ai reçu [Abounasr Najihi Boujadi] depuis la machine Adresse 127.0.0.1
port :5888
Le paquet est créé !
Le paquet est envoyé !
Console Serveur
Console Client

CHAPITRE 5 :
Comparaison socket JAVA
ET C

le principe des sockets reste le même dans les deux langages, la comparaison
sera faite au niveau des syntaxes du code utilisé dans chaque langage :
5.1 En mode Connecté
5.1.1 Côté serveur
JAVA En Unix /C
- Créer un Socket
- L’Attacher à un port
et adresse
- Lui permettre de
scruter et stocker
les demandes de
connexions
entrantes avant
acceptation
- paramétrer la taille
de la FIFO des
requêtes
Classe ServerSocket
Trois constructeurs
possibles :
- numéro_port
(obligatoire)
- Et taille
maximale FIFO
- Et Adresse IP
PS : cette classe fait les
3 taches de langage C
socket()+bind()+listen()
- socket()
//création en mode
STREAM
- bind()
//assignation
numéro de port et
adresse IP
- listen()
// taille maximale FIFO
- Le processus doit
être bloqué tant
qu’aucune demande
de connexion ne lui
parvient sur la
socket générique
d’écoute : = =>
fonction bloquante
- L’acceptation
consiste à
considérer
positivement une
demande reçue et à
Classe ServerSocket
Méthode accept
// retourne un objet
Socket
accept
// retourne
l’identificateur de la
nouvelle créée ainsi
que les
caractéristiques du
client distant

créer localement
une socket
spécifique dédiée à
supporter l’échange
de données sur cette
connexion
particulière
==> Cette socket
représente l’extrémité
« serveur » de la
connexion TCP initiée
par un « client »
distant.
- EMISSION : Revient à
Ecrire/Envoyer un
message (x octets)
sur la connexion
- RECEPTION : Revient
à Lire/Recevoir un
message (x octets)
sur la connexion
Classe Socket
- Emission :
méthode
getInputStream
Réception :
méthode
getOuputStream
- Emission :
primitives send ou
write
- Réception :
primitives recv ou
read

5.1.2 Client
JAVA En Unix /C
- Créer un Socket
- L’attacher à un port
et adresse
- L’utiliser pour
demander
l’établissement
d’une connexion
TCP avec un
processus distant «
répondant »
Quatre constructeurs
possibles
- Adresse IP ou
nom_host distant ET
numéro_port
distant
(obligatoires)
- Et Adresse IP ou
nom_host local ET
numéro_port local
PS : cette classe fait les 3
taches de langage C
socket()+bind()+connect()
- socket()
// création en
mode STREAM
- bind()
// assignation
numéro de port et
adresse IP
- connect()
//permet à un
client de se
connecter à le
serveur.
EMISSION : Revient à
Ecrire/Envoyer un
message (x octets) sur
la connexion
RECEPTION : Revient à
Lire/Recevoir un
message (x octets) sur
la connexion
Classe Socket
- Emission : méthode
getInputStream
- Réception :
méthode
getOuputStream
Emission :
primitives send ou
write
Réception :
primitives recv ou
read
5.1.3 Récpitulatif
 Version Unix/) :

 Version JAVA :

5.2 En mode déconnecté
5.2.1 Côté serveur et côté Client
JAVA En Unix /C
- Créer une socket
localement
- Numéro de port
prédéfini côté «
serveur »
Créer un socket UDP
avec
- DatagramSocket (int
port) :Côté serveur
- DatagramSocket() :
côté client
Créer le socket UDP
avec la fonction
socket () +
La fonction bind()
pour l’attacher à un
port
Transfert de données
(des deux côtés) :
EMISSION : Envoyer X
octets vers une socket
distante dont on
précise les
caractéristiques
RECEPTION : Recevoir
X octets provenant
d’une socket distante
dont on récupère les
caractéristiques pour
en déterminer
l’origine ==> fonction
bloquante
Classe SocketDatagram
- Emission :
méthode send
- Réception :
méthode receive
Classe DatagramPacket
- Constructeurs
pour l’envoi
- Constructeurs
pour la réception
Emission : primitives
sendto
Réception :
primitives recvfrom
5.2.2 Récapitulatif
 Version Unix/C :

 Version Java :

Rapport Sockets en Java

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Rapport Sockets en Java

Similaire à Rapport Sockets en Java (20)

Plus de Soukaina Boujadi

Plus de Soukaina Boujadi (15)

Dernier

Dernier (20)

Rapport Sockets en Java