Sockets en java - Rapport

2 761 vues

Publié le

Publié dans : Formation
0 commentaire
2 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
2 761
Sur SlideShare
0
Issues des intégrations
0
Intégrations
5
Actions
Partages
0
Téléchargements
131
Commentaires
0
J’aime
2
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Sockets en java - Rapport

  1. 1. 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
  2. 2. 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
  3. 3. 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 Année Universitaire 2013-2014 3
  4. 4. 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 Année Universitaire 2013-2014 4
  5. 5. CHAPITRE 1: Introduction au sockets Année Universitaire 2013-2014 5
  6. 6. 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. Année Universitaire 2013-2014 6
  7. 7. 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. Année Universitaire 2013-2014 7
  8. 8. 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) Année Universitaire 2013-2014 8
  9. 9.  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 Année Universitaire 2013-2014 9
  10. 10. CHAPITRE 2: Qu'est-ce qu'un socket ? Année Universitaire 2013-2014 10
  11. 11. 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é Année Universitaire 2013-2014 11
  12. 12. 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... Année Universitaire 2013-2014 12
  13. 13. CHAPITRE 3 : Socket en mode connecté Année Universitaire 2013-2014 13
  14. 14. 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. Année Universitaire 2013-2014 14
  15. 15. 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 Année Universitaire 2013-2014 15
  16. 16. 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 (). Année Universitaire 2013-2014 16
  17. 17. 3.1.6 Overview 3.2 Socket TCP - Déroulement Année Universitaire 2013-2014 17
  18. 18. 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 : Année Universitaire 2013-2014 18
  19. 19. 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 Année Universitaire 2013-2014 19
  20. 20. import java.io.*; import java.net.*; import java.util.Scanner; public class Client { public static void main(String[] args) { 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(); }}} Année Universitaire 2013-2014 20
  21. 21.  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: Génération de objet InptStream et OutputStream de la socket Lire un nombre au clavier NB=_ Console Client  Saisir un nombre par le client et l’envoyer au serveur : Année Universitaire 2013-2014 21
  22. 22. 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) ! J’envoie la réponse Déconnexion du client Console Serveur Créer une connexion au serveur: Génération de objet InptStream et OutputStream de la socket 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 Année Universitaire 2013-2014 22
  23. 23. 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 Année Universitaire 2013-2014 23
  24. 24. Connections multithread 3.4.2 Déroulement en multi-thread Année Universitaire 2013-2014 24
  25. 25. 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(); .... Année Universitaire 2013-2014 25
  26. 26. 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 : Année Universitaire 2013-2014 26
  27. 27. 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 public static void main(String[] args) { new ServeurMultiThread().start(); }} Année Universitaire 2013-2014 27
  28. 28.  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();} } } Année Universitaire 2013-2014 28
  29. 29.  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 : J'attend une connexion J'attend une connexion Client Num 1 J'attend une connexion Client Num 2 Vous etes le client num 1 Vous etes le client num 2 Console Serveur Client 1 Client 2 Année Universitaire 2013-2014 29
  30. 30.  Communication entre les clients et le serveur : J'attend une connexion J'attend une connexion Client Num 1 J'attend une connexion Client Num 2 Vous etes le client num 1 Soukaina Votre commande contient 8 caractères Meryem Votre commande contient 6 caractères Console Serveur Vous etes le client num 2 MQL Votre commande contient 3 caractères UNIX Votre commande contient 4 caractères Client 1 Client 2 Année Universitaire 2013-2014 30
  31. 31. CHAPITRE 4 : Socket en mode non connecté Année Universitaire 2013-2014 31
  32. 32. 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); Année Universitaire 2013-2014 32
  33. 33.  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) Année Universitaire 2013-2014 33
  34. 34. 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. Année Universitaire 2013-2014 34
  35. 35. 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. Année Universitaire 2013-2014 35
  36. 36. 4.3 Socket UDP:Déroulement  Un schéma récapitulatif Année Universitaire 2013-2014 36
  37. 37. 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); }}} Année Universitaire 2013-2014 37
  38. 38.  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); }}} Année Universitaire 2013-2014 38
  39. 39.  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 Année Universitaire 2013-2014 39
  40. 40. CHAPITRE 5 : Comparaison socket JAVA ET C Année Universitaire 2013-2014 40
  41. 41. 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 Année Universitaire 2013-2014 41
  42. 42. 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 Année Universitaire 2013-2014 42
  43. 43. 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/) : Année Universitaire 2013-2014 43
  44. 44.  Version JAVA : Année Universitaire 2013-2014 44
  45. 45. 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 : Année Universitaire 2013-2014 45
  46. 46.  Version Java : Année Universitaire 2013-2014 46
  47. 47. Année Universitaire 2013-2014 47

×