Architecture Client-Serveur PDF

# Architecture Client Serveur ## Socket TCP: Lecture de données avec un ServerSocket ### La classe InputStream en Java - La classe `InputStream` en Java est une classe abstraite qui représente un flux d'entrée de données. ### Méthodes importantes: - **`int read()`**: Lit le prochain octet de do...

# Architecture Client Serveur ## Socket TCP: Lecture de données avec un ServerSocket ### La classe InputStream en Java - La classe `InputStream` en Java est une classe abstraite qui représente un flux d'entrée de données. ### Méthodes importantes: - **`int read()`**: Lit le prochain octet de données à partir du flux. - Retourne l'octet sous forme d'un entier (int). - Retourne -1 si la fin du flux est atteinte. - **`int read(byte[] b)`**: Lit plusieurs octets à la fois et les stocke dans un tableau de bytes `b`. - Retourne le nombre d'octets lus. - Retourne -1 si la fin du flux est atteinte. - **`int read(byte[] b, int offset, int len)`**: Lit `len` octets du flux et les place dans le tableau de bytes `b`, à partir de la position `offset`. - Retourne le nombre d'octets effectivement lus. - Retourne -1 si la fin du flux est atteinte. ## Socket TCP: Lecture de données avec un ServerSocket ### La classe OutputStream en Java - La classe `OutputStream` en Java est une classe abstraite qui représente un flux de sortie de données. ### Méthodes importantes: - **`void write(int b)`**: Écrit un octet (représenté par un entier) dans le flux de sortie. - Le paramètre `b` est l'octet à écrire, qui est automatiquement converti en un entier entre 0 et 255. - Cette méthode écrit un seul octet à la fois. - **`void write(byte[] b)`**: Écrit un tableau d'octets dans le flux de sortie. - Cette méthode écrit tous les octets du tableau dans l'ordre où ils apparaissent. - **`void write(byte[] b, int offset, int len)`**: Écrit une portion du tableau d'octets, commençant à partir de l'index `offset` et de longueur `len`. - Cela permet d'écrire un sous-ensemble du tableau au lieu de l'écrire en entier. ## Architecture Client Serveur ## Socket TCP: La Classe Socket - La classe `java.net.Socket` nous permet de gérer les opérations pouvant être effectuées sur une socket. ### Méthodes importantes: - Les méthodes de cette classe peuvent être appelées soit par un processus client ou serveur. - Un processus client qui se connecte à un serveur doit créer une instance de la classe `Socket`. - La classe `Socket` offre deux constructeurs possibles: - **`public Socket(String hote, int port) throws UnknownHostException, IOException`**: Ce constructeur permet de créer une instance de la classe `Socket` entre un processus client (local) et un processus serveur en attente de connexion sur le port `port` de la machine `hote`. - **`public Socket(InetAddress address, int port) throws IOException`**: Ce constructeur permet de créer une instance de la classe `Socket` entre un processus client (local) et un processus serveur en attente de connexion sur le port `port` de la machine dont l'adresse IP est `address`. - Les méthodes `getInputStream()` et `getOutputStream()` permettent d'obtenir un flux de données d'entrée et/ou un flux de données de sortie par le processus client une fois une instance de la classe `Socket` est créée. - Ces méthodes renvoient des instances de classes dérivant des classes `InputStream` et `OutputStream` dont les méthodes permettent de lire (Read) et envoyer (Whrite) les données entre le client et le serveur. ## Architecture Client Serveur ## Socket TCP: Lecture de données avec un Socket ### Etablir une connexion: - Se traduit par la création des sockets coté client et côté serveur. ### Fermer une connexion: - Se traduit par la destruction de ces sockets créés. ## Architecture Client Serveur ## Appels de fonction socket - La classe Socket possède de nombreuses méthodes dont les principales sont: ### Méthodes importantes: - **`socket()`**: Créer un objet socket. - **`bind()`**: Lier un socket à une adresse IP locale et un port #. - **`Listen()`**: Attente passive des connexions. - **`connect()`**: Lancement de la connexion à un autre socket. - **`accept()`**: Accepter une nouvelle connexion. - **`Write()`**: Ecrire des données sur un socket. - **`Read()`**: Lire les données d'un socket. - **`sendto()`**: Envoyer un datagramme vers un autre socket UDP. - **`recvfrom()`**: Lire un datagramme depuis un socket UDP. - **`close()`**: Fermer un socket (fermer la connexion). - **`getInputStream()`**: Renvoie un flux en entrée pour recevoir les données de la socket. - **`getOutputStream()`**: Renvoie un flux en sortie pour émettre les données de la socket. ## Architecture Client Serveur ## Socket TCP: Lecture et Ecriture de données (Octet) avec un Socket ### Code serveur ```java ServerSocket ss=new ServerSocket(1234); Socket s=ss.accept(); InputStream is=s.getInputStream(); OutputStream os=s.getOutputStream(); int nb=is.read(); int rep=nb*2; os.write(rep); ``` ### Code client ```java Socket s=new Socket("192.168.1.23,1234) InputStream is=s.getInputStream(); OutputStream os=s.getOutputStream(); os.write(23); int rep=is.read(); ``` ## Architecture Client Serveur ## Socket TCP: Construction de socket serveur ### Lancement du serveur sur un Port ```java ServerSocket socketServeur = new ServerSocket (port, 50, InetAddress.getByName("192.168.254.251")); ``` ### Lancement du serveur sur IP et Port ```java InetAddress AdrIP = InetAddress.getByName("192.168.254.251"); Socket socket = new Socket(AdrIP, port); ``` ## Architecture Client Serveur ## Socket TCP: Lecture et Ecriture des chaines de caractères ### La classe InputStreamReader en Java - La classe `InputStreamReader` en Java est utilisée pour lire des données d'un flux d'entrée (un `InputStream`), mais elle les convertit en caractères en utilisant un encodage spécifique. #### Méthodes importantes: - **`InputStream/OuputStream`**: Ce filtre permet de convertir des octets en caractères. - **`Java définit un InputStreamReader comme un pont entre les flux d'octets et les flux de caractères`**: - **`Buffered`**: Ce type de filtre permet de mettre les données du flux dans un tampon. - **`La classe BufferedReader (héritées de Reader) permet de lire un ou plusieurs caractères dans le flux`**: - **`La méthode ReadLine() définit dans la classe BufferedReader nous permet de lire une ligne de caractères dans le flux`**: - **`La classe BufferedWriter nous permet de créer des flux de caractères tamponnés en écriture`**: Cette classe est très utile pour écrire des données de manière plus performante en utilisant un tampon. - **`La classe PrintWriter nous permet d'écrire dans un flux des données formatées`**: ## Architecture Client Serveur ## Socket TCP: Lecture et Ecriture des chaines de caractères ### InputStreamReader - Un `InputStreamReader` est un pont entre les flux d'octets et les flux de caractères : il lit les octets et les décode en caractères à l'aide d'un jeu de caractères spécifié. - Le jeu de caractères qu'il utilise peut être spécifié par: - Son nom - Ou le jeu de caractères par défaut de la plateforme peut être accepté. ### Donné explicitement : ```java InputStreamReader isr = new InputStreamReader(socket.getInputStream(), "UTF-8"); BufferedReader flux_entrant = new BufferedReader(isr); Flux_entrant.readline() ``` ### Ou bien par son nom: ```java InputStream ins = socket.getInputStream(); InputStreamReader inr= new InputStreamReader(ins); BufferedReader flux_entrant = new BufferedReader(isr); Flux entrant.readline() ``` ## Architecture Client Serveur ## Socket TCP: Lecture et Ecriture des chaines de caractères ### Création de l'objet ServerSocket ```java ServerSocket ss=new ServerSocket(2345); ``` ### Attendre une connexion d'un client ```java Socket sock=ss.accept(); ``` ### Pour lire une chaîne de caractère envoyée par le client ```java InputStream is=sock.getInputStream(); InputStreamReader isr=new InputStreamReader(is); BufferedReader br=new BufferedReader(isr); String s=br.readLine(); ``` ### Pour envoyer une chaîne de caractères au client ```java OutputStream os=sock.getOutputStream(); PrintWriter pw=new PrintWriter(os,true); pw.println("Chaîne de caractères"); ``` ## Architecture Client Serveur ## Socket TCP: Lecture et Ecriture des chaines de caractères ### Exemple: ```java InputStream in = socketClient.getInputStream(); OutputStream out = socketClient.getOutputStream(); InputStreamReader inr= new InputStreamReader(in); PrintWriter pw new PrintWriter(out, true); BufferedReader br= new BufferedReader (inr); Scanner sc= new Scanner(System.in); pw.println(a); ``` ## Architecture Client Serveur ## Socket TCP: Lecture et Ecriture des chaines de caractères ### Coté serveur ```Java package Test3; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io. PrintWriter; import java.net.*; public class Serveur Socket { final static int port = 1234; public static void main(String[] args) { try { ServerSocket socketServeur = new ServerSocket(port); System.out.println("Lancement du serveur sur IP et Port: "+socketServeur.getLocalSocketAddress()); while (true) { Socket socketClient = socketServeur.accept(); System.out.println("Connexion avec IP: "+socketClient.getInetAddress()+ "et le port "+socketClient.getLocalPort()); InputStream in = socketClient.getInputStream(); OutputStream out = socketClient.getOutputStream(); InputStreamReader inr= new InputStreamReader(in); PrintWriter pw =new PrintWriter(out,true); BufferedReader br= new BufferedReader(inr); System.out.println("J'attend la 1ère chaine de caractères"); String a = br.readLine(); System.out.println(" la 1ère chaine est: "+a); System.out.println(" J'attend la 2ème chaine de caractères"); String b = br.readLine(); System.out.println(" la 2eme chaine : "+b); //Concatenation des chaines de caractères de la somme String resch =(a+" "+b); System.out.println("Réponse envoyée"); pw.println(resch); socketClient.close(); } } catch (Exception e) { e.printStackTrace(); } } } ``` ## Architecture Client Serveur ## Socket TCP: Lecture et Ecriture des chaines de caractères ### Coté client ```Java import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.*; import java.util.Scanner; public class ClientSocket { final static int port = 1234; public static void main(String[] args) { try { InetAddress AdrIP = InetAddress.getByName("192.168.254.251"); Socket socket = new Socket(AdrIP, port); InputStream in = socket.getInputStream(); OutputStream out = socket.getOutputStream(); InputStreamReader inr= new InputStreamReader(in); PrintWriter pw =new PrintWriter(out,true); BufferedReader br= new BufferedReader(inr); Scanner sc= new Scanner(System.in); System.out.println("Entrer la 1ère chaine de caractères"); String a=sc.nextLine(); System.out.println("Entrer la 2ème haine de caractères"); String b=sc.nextLine(); pw.println(a); pw.println(b); String ch=br.readLine(); System.out.println("Resultat :"+ch); sc.close(); in.close(); out.close(); socket.close(); } catch (Exception e) { e.printStackTrace(); } } } ``` ## Architecture Client Serveur ## Socket TCP: Sérialisation-Désérialisation Binaire ### La sérialisation binaire en Java - La sérialisation binaire en Java est un moyen puissant pour stocker et transférer des objets. - Elle utilise les classes `ObjectOutputStream` et `ObjectInputStream` pour écrire et lire des objets. - La sérialisation permet de persister des objets dans un fichier ou de les envoyer sur un réseau, et la désérialisation permet de reconstruire l'objet à partir de ses données binaires: ### Méthodes importantes: - **`Sérialisation`**: Permet de sauvegarder des objets dans un fichier. - **`Désérialisation`**: Permet de restaurer des objets à partir d'un fichier. ### Deux classes du package `java.io` sont utilisées: - **`ObjectOutputStream`**: Pour la sérialisation est une technique en Java permettant de convertir des objets en un flux de données binaire. - **`ObjectInputStream`**: Pour la desérialisation permet de reconstruire les objets à partir du flux binaire. - **`Flux binaires`**: Les systèmes distribués utilisent souvent des flux binaires pour envoyer des objets ou des données complexes entre différentes machines ou services. ### Création des objets pour lire et envoyer des données: ```java ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream()); ObjectInputStream ois = new ObjectInputStream(socket.getInputStream()); ``` ## Architecture Client Serveur ## Socket TCP: Sérialisation-Désérialisation Binaire ### La sérialisation binaire - La sérialisation binaire consiste à transformer un objet ou une structure de données (une liste ou un objet d'une classe) en une séquence d'octets. - Ces octets peuvent être stockés dans un fichier ou envoyés sur un réseau. - Le format binaire est plus compact et plus rapide à traiter que d'autres formats comme le texte, car il est directement interprété par la machine. ### But: - Permet de stocker ou transmettre des objets complexes de manière compacte. ### La désérialisation binaire - La désérialisation binaire est le processus inverse de la sérialisation. Il consiste à reconstruire l'objet à partir de sa représentation binaire. ### Lire ### But: - Reconstituer un objet à partir de données binaires afin qu'il soit réutilisable dans l'application. ### Envoyer ### Pour sérialiser un objet (envoyer un objet vers le client) ```java OutputStream os=sock.getOutputStream(); ObjectOutputStream cos=new ObjectOutputStream(os); cos.write@bject (p); ``` ### Pour lire un objet envoyé par le client (désérialisation) ```java InputStream is=sock.getInputStream(); ObjectInputStream ois naw ObjectInputStream(is); ``` ## Architecture Client Serveur ## Socket TCP: Sérialisation-Désérialisation Binaire ### Méthodes ```java ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream()); oos.writeln (12345); oos.writeObject("Today"); oos.writeObject(new Date()); oos.writeFloat(a); oos.close(); ObjectInputStream ois.= new ObjectInputStream(socket.getInputStream()); int a =ois.readInt(); float a =ois.readFloat(); String c = (String)ois.readObject(); float ch=(float)ois.readObject(); ois.close(); ``` ## Architecture Client Serveur ## Socket TCP: INETRFACE RESEAU SOCKET - Un **socket** est l'un des points d'extrémité d'un lien de communication bidirectionnel entre deux programmes exécutés sur le réseau. - Le **socket** est lié à un numéro de port afin que la couche TCP puisse identifier l'application à laquelle les données sont destinées à être envoyées. - Le but de cette application est de réaliser une **calculatrice distribuée** à l'aide des interfaces Sockets. ### Contraintes : - Vous travaillez en mode connecté - Cette calculatrice travaille sur deux nombres réels et un opérateur de votre choix. - Elle supporte quatre types d'opérations à savoir: Additions, Soustractions, Multiplications et Divisions selon l'opérateur choisi par l'utilisateur. ### Donc, selon l'opérateur choisi par le client, elle affiche coté client : - **`/`**: Résultat de la division est: 12.555 - **`*`**: Résultat du produit est: 12.555 - **`+`**: Résultat de la somme est: 12.555 - **`-`**: Résultat de la soustraction est: 12.555 ## Architecture Client Serveur ## Socket TCP: INETRFACE RESEAU SOCKET ### Le serveur recevra comme requête de la part d'un client donné une opération à réaliser sur deux nombres réels, sous la forme d'un message formaté comme suit: - **Entrer le ler nombre: 12,5** - **Entrer le 2eme nombre: 25** - **Entrer un opérateur: * ** - **Resultat du produit est: 187.5** - **Il retoumera comme réponse le résultat de l'opération effectuée.** - **Le résultat sera affiché sur la console du client.** ## Architecture Client Serveur ## Socket TCP: Sérialisation-Désérialisation Binaire ### Serializable - La classe d'un objet doit implémenter l'interface Serializable pour être sérialisée. - Cette interface est un marqueur (sans méthodes à implémenter) qui indique que la classe peut être sérialisée. ### FileOutputStream - Ce flux est utilisé pour écrire des octets dans un fichier, nommé NamFile.ser. - Lors d'exécution d'un programme, l'objet de la classe est sérialisé dans un fichier binaire appelé NamFile.ser. ### ObjectOutputStream - C'est le flux qui permet de sérialiser l'objet et de l'écrire dans le flux de sortie. ### FileInputStream - Utilisé pour lire le fichier binaire qui contient l'objet sérialisé. ### ObjectInputStream - Ce flux est utilisé pour désérialiser l'objet depuis le flux d'entrée. ### Champ serialVersionUID - Il est recommandé de définir un champ `serialVersionUUID` pour chaque classe sérialisée. - Cela permet de gérer la compatibilité entre différentes versions de la classe sérialisée. - Si la version de la classe a changé entre la sérialisation et la désérialisation, une exception `Invalid ClassException` pourrait être lancée si les versions ne correspondent pas. ## Architecture Client Serveur ## Socket TCP ou Datagram UDP ### Couche transport - Dans la couche transport, nous distinguons deux grands modes de communication: #### Par paquet (DataGram): - Il n'existe pas d'ordre dans la délivrance des paquets, ainsi, un paquet posté en premier peux arriver en premier. - Cette communication se fonde sur le protocole UDP, donc, les paquets envoyés peuvent être perdus: - dialogue sans connexion, sans segmentation, avec commutation des paquets, sans garantir de la fiabilité… #### En flux (Stream): - Dialogue avec connexion, avec segmentation, commutation des paquets, garantir de la fiabilité,… ### Cette couche propose deux grands protocoles de communication: - TCP or Transmission Communication Protocol - Connexion fiable entre deux services - Orienté connexion, bidirectionnel, point à point, fiable, conserve l'état de la connexion - UDP or User DataGram Protocol - Envoi de paquets de données - Absence de gestion des paquets ## Architecture Client Serveur ## Socket TCP ou Datagram UDP ### Couche application - Dans la couche application, une application fournit un service particulier sur une machine donnée: #### Méthodes importantes: - Le service est identifié par un numéro de port donné. - La machine est identifié par une adresse IP publique donnée. - Un point de communication est identifié par le couple (adresse, port). Ainsi, toute communication ne peut être effectuée qu'entre deux points de communications: Emetteurs et Récepteurs. #### Classes du package Java.net. utilisées pour communiquer à base du Protocole TCP sont: - **`InetAddress`**: Codage des adresses IP. - **`Socket`**: Interface socket en mode connecté. - **`ServerSocket`**: Socket d'attente, côté serveur, d'une demande de connexion de la part d'une client donné. ## Architecture Client Serveur ## Socket TCP ou Datagram UDP ### La classe InetAddress - La classe `InetAddress` n'a pas de constructeur. Donc, pour instancier un objet nous devons passer par la méthode static `getByName()`: ```java Public static InetAddress getByName(String Host) throws UnKnounHostException ``` - Cette méthode nous permet de créer un objet `InetAddress` identifiant une machine dont le nom est passéen argument. - L'exception est levée si le service DNS du système ne trouve pas une machine identifiée par le nom passé en argument sur le réseau. #### Exemple: ```java InetAddress AdrIPg = InetAddress.getByName("www.google.com"); System.out.println("Adresse de google: "+AdrIPg); ``` - Affiche: Adresse de google: www.google.com/142.250.200.100 ### Retourner l'adresse IP locale de la machine sur laquelle elle tourne le programme: ```java Public static InetAddress getLocalHost() throws UnKnounHostException ``` ### Retourner le nom de la machine dont le nom est codé par l'objet InetAddress: ```java Public String getHostName(); ``` ## Architecture Client Serveur ## Socket TCP ou Datagram UDP ### Le constructeur de la classe Socket - Le constructeur de la classe `Socket` nous permet d'instancier un objet socket local et le connecte à un port disant d'une machine distante identifiée par le point de communication Adresse/Port: ```java Public Socket(InetAddress Address, Int Port) throws IOException ``` ### Ce constructeur est surchargé: ```java Public Socket(String Address, Int Port) throws IOException, UnKnounHostException ``` - L'exception `UnKnounHostException` est levée si le service DNS du système ne trouve pas une machine identifiée par le nom passé en argument sur le réseau. ### Méthodes d'émission et de réception des flux de données sont: - **`OutputStream getOutputStream()`**: retourne le flux de sortie permettant d'envoyer les données vis le socket. - **`InputStream getInputStream()`**: retourne le flux d'entrée permettant de recevoir les données vis le socket. ## Architecture Client Serveur ## Socket ou Datagram UDP ### Le mode Datagramme - Le mode Datagramme est caractérisé par: #### Méthodes importantes: - L'envoi des paquets de données (Datagrammes). - Pas d'établissement d'une connexion entre les entités communicantes. - Il ne préserve pas l'état d'une connexion. - Il ne garantie pas la fiabilité d'échange. - Les paquets peuvent être perdus dans le réseau. - L'ordre d'arrivé des paquets n'est pas garanti. Il dépend de la gestion des routes empruntés par les paquets dans le réseau. ### Pour lancer un processus de communication: - Le serveur crée un `DatagramSocket` et le lie un port UDP. - Le client crée un `DatagramSocket` pour accéder à la couche UDP et le lie à un port quelconque. - Le serveur se met en attente de réception de paquet sur son objet `DatagramSocket`. - Le client envoje un `DatagramPaquet` via son `DatagramSocket` en précisant l'adresse du destinataire: IP et Port, - Adresse IP de la machine sur laquelle tourne la partie serveur - Numéro de port sur lequel est liée le socket de la partie serveur. ### Si le client envoie un paquet avant que le serveur ne soit prêt à recevoir les paquets le paquet est perdu. ## Architecture Client Serveur ## Datagram UDP: Classe DatagramPacket - Java intègre les fonctionnalités de communication réseau au dessus de la couche transport. - Parmi ces classes, nous citons la classe DatagramPacket qui nous permet d'envoyer un paquet de données vis un socket sans connexion. ### La structure de données que un client peuvent envoyer, est défini par le constructeur de la classe DatagramPacket: ```java public DatagramPacket(byte[] buf, int length); ``` - Créer un paquet pour recevoir des données sous forme d'un tableau des octets. - Les données reçues seront met dans le `buf`. - La taille `length` précise la taille de données à lire: - Il est recommandé de ne pas dépasser la taille d'un datagramme UDP. - À ne pas choisir une taille plus grande que celle du tableau `buf`. ## Architecture Client Serveur ## Socket ou Datagram UDP ### Les méthodes de base pour gérer un tel échange de données sont: - **`getAddress`**: Si nous avons un paquet à envoyer, elle correspond à l'adresse de la machine distante. Si nous avons reçu un paquet, elle correspond à l'adresse de la machine distante qui a envoyé le paquet reçu. - **`getPort`**: Si nous avons un paquet à envoyer elle correspond au port d'écoute sur de la machine distante. Si nous avons reçu un paquet, elle correspond au port utilisé par la machine distante qui a envoyé le paquet reçu. - **`getData`**: Cette méthode retourne un tableau des octets équivalent aux données contenues dans le paquet à envoyer. - **`getLength`**: Si nous avons un paquet à envoyer, elle correspond à la taille des données à envoyer. Si nous avons reçu un paquet, elle correspond à la taille des données reçues. - **`setAddress`**: Permet de positionner l'adresse IP de la machine distante. - **`setPort`**: Permet de positionner le numéro d'un service dans la machine distante. - **`setData`**: Permet de remplir un tableau des octets équivalent aux données contenues dans le paquet à envoyer. - **`setLength`**: Permet de positionner la taille d'un tableau des octets équivalent aux données contenues dans le paquet à envoyer. ## Architecture Client Serveur ## Socket ou Datagram UDP ### Les paquets dataGram UDP circulent sur le réseau à base de l'encapsulation UDP. Pour gérer un tel échange de données nous respectons les critères suivants: - La taille maximale d'un paquet des données est de 2¹⁶ environ de 64ko. - Le contrôle d'intégrité est optionnel dans une communication à base de l'adresse IPv4. - Le contrôle d'intégrité est obligatoire dans une communication à base de l'adresse IPv6. - La cominutation d'un datagramme UDP en plusieurs datagrammes IP est assurée par la couche réseau. - Pratiquement, il est déconseillé de dépasser une taille de 8ko. - La plupart des systèmes limitent la taille d'un paquet UDP à 8ko. - Si un paquet UDP a une taille plus grande que la taille du tableau `buf` retourné par la méthode `getData()`, les données à envoyer seront tronquées. - Également, si un paquet UDP reçu a une taille plus grande que la taille du tableau `buf` retourné par la méthode `getData()`, les données reçues seront aussi tronquées. ## Architecture Client Serveur ## Datagram UDP: Classe DatagramPacket ### Parmi les méthodes de la classe DatagramSocket qui nous permet de créer un socket sans connexion, nous citons: - **`public DatagramSocket() throws SocketException;`**: Créer un nouveau socket lié à n'import quel port libre. - **`public DatagramSocket(int port) throws SocketException;`**: Créer un nouveau socket lié à un port local libre. ### Méthode d'émission des paquets: - **`Public void send (DatagramPacket paquet) throws IOException;`**: Envoie le paquet passé en paramètre. La machine distante est identifié dans le paquet. - **`Exception levée en cas des problèmes d'entrées-sorties;`**: ## Architecture Client Serveur ## Datagram UDP: Classe DatagramPacket ### Méthode de réception des paquets: - **`Public void receive( DatagramPacket paquet) throws IOException;`**: Reçoit un paquet de données envoyer par un tel client. - **`Il reste bloqué jusqu'à avoir un paquet reçu.`**: - **`Les attributs du paquet paquet seront modifiés à la réception d'un nouveau paquet.`**: - **`Les données reçues seront copiées dans le tableau passé en argument lors de la création de paquet et sa longueur est calculé à base de la taille des paquets reçus.`**: - Le couple (Adresse, port) contient l'adresse IP et le port de la socket distante qui a émis le paquet. - **`Exception levée en cas des problèmes d'entrées-sorties;`**: ### Exemple: ```java try { DatagramSocket socket = new DatagramSocket(); DatagramPacket donnees Emises = new DatagramPacket(buffer, length, serveurIP, port); DatagramPacket donnees Recues = new DatagramPacket(new byte[toille], taille); socket.send(donnees Emises); socket.receive (donnees Recues); } catch (Exception e) {e.printStackTrace();}} ``` ## Architecture Client Serveur ## Datagram UDP: Classe DatagramPacket ### Méthode de réception des paquets: - **`Public void receive( DatagramPacket paquet) throws IOException;`**: - Méthode bloquante sans contrainte de temps: elle reste en attente indéfiniment si aucun paquet de données n'est jamais reçu. - **`Nous pouvons préciser un délai maximum d'attente`**: - L'appel de la méthode `receive` sera bloquante pendant au plus `timeout` en millisecondes. - **`Cette méthode pourra être de deux façons`**: - Elle retourne normalement si un paquet est reçu en moins du temps positionné par l'appel de `setSoTimeout`. - L'exception `SocketTimeoutRxception` est levée pour indiquer que le délai d'attente est écoulé avant qu'un paquet ne soit reçu. ### Exemple: ```java try {DatagramSocket socket = new DatagramSocket(); socket.setSoTimeout(30000); socket.send(donnees Emises); } catch (SocketTimeoutException ste) { System.out.println("Le delai pour la reponse a expire");} ``` ## Architecture Client Serveur ## Socket ou Datagram UDP ### Diagramme - **Client**: - `socket()`: Création de la socket - `bind()`: Assignation n'port - @IP - `sendto()`: envoi requête - `close()`: Fermeture de la socket - **Serveur**: - `socket()`: Création de la socket - `bind()`: Assignation n'port - @IP - `recvfrom()`: envoi réponse - `sendto()`: - `close()`: Fermeture de la socket