PARTIE 2 : La programmation réseau en Java que l'adresse de destination n'est pas

nécessaire à chaque envoi de données.

Comme pour les threads, Java possède en standard • Le mode non connecté (analogue à une
une API permettant de programmer des applications communication par courrier), utilisant le
réseau (client –serveur) , en utilisant des sockets . protocole UDP. Ce mode nécessite l'adresse de
destination à chaque envoi, et aucun accusé de
1. Présentation réception n'est donné.

Une socket est une notion très répandue en Les sockets utilisant le protocole TCP fonctionnent en
programmation réseau, en particulier sous UNIX. Il s'agit utilisant le modèle client/serveur et offrent une
d'un modèle permettant la communication inter communication par flux. Les sockets utilisant le
processus (IPC - Inter Process Communication) afin de protocole UDP se basent sur des échange de paquets –
permettre à divers processus de communiquer aussi appelés datagrammes dans le monde TCP/IP . Les
bien sur une même machine qu'à travers un réseau sockets UDP peuvent de plus être utilisés pour une
TCP/IP. Un processus client et un processus serveur, communication entre une application et un groupe de
lorsqu'ils communiquent, ouvrent donc chacun une machines (diffusion plus ou moins restreinte – broadcast
socket. A chaque socket est associé un port de ou multicast).
connexion. Ces numéros de port sont uniques sur un
système donné, une application pouvant en utiliser 2. Les sockets TCP en Java
plusieurs (un serveur par exemple exploite une socket
par client connecté). Certains numéros sont réservés Java distingue les sockets clientes des sockets serveurs
pour des applications (ou protocoles) précises, par en deux classes, respectivement Socket utilisée par les
exemple le port 80 est réservé aux serveurs web clients et ServerSocket par les serveurs, contenues
(HTTP). Ces ports réservés ont un numéro inférieur à dans le package java.net.
1024.
La classe Socket
Pour maintenir l’unicité des numéros de port (par
protocole) on les a répartis en trois catégories : La classe Socket est utilisée par les clients TCP.

- Les ports systèmes (appelés aussi ports bien Pour créer un objet de la classe Socket, il est nécessaire
connus – well known ports) de 0 à 1023 sont d'utiliser un des constructeurs suivant :
réservés sous UNIX au processus démarrés
automatiquement par le système d’exploitation et
• public Socket (String machine, int port)
peuvent être déposés auprés de l’organisme IANA
throws UnknownHostException, IOException
(Internet Assigned Numbers Authority).
• public Socket (InetAddress adresse, int port)
throws UnknownHostException, IOException
- Les ports utilisateurs (appelés aussi ports
• public Socket(String machine, int port,
déposés – registered ports) de 1024 à 49151 sont
InetAddress local, int portLocal)
disponibles pour les utilisateurs et peuvent eux
throws IOException
aussi être déposés auprès de l’organisme IANA.
• public Socket(InetAddress adresse, int port,
InetAddress local, int portLocal)
- Les ports dynamiques (appelés aussi ports throws IOException
privés) de 49152 à 65535.
La création d'un objet Socket entraîne la création d'un
Une connexion est identifiée de façon unique par la point de connexion (la socket) et la connexion vers une
donnée de deux couples, une adresse IP et un numéro autre socket (le serveur).
de port, un pour le client et un autre pour le serveur. L'adresse du serveur est composée de l'adresse d'une
machine (sous forme d'un nom ou d'un objet de la
Ainsi, avec Java, il est très facile d'ouvrir une connexion classe InetAddress) et d'un numéro de port.
réseau TCP/IP depuis une applet ou une application. La
classe Socket fournit tous les outils nécessaires à cela. L'adresse locale et le port local peuvent également être
Une fois qu'une connexion est réalisée avec une autre spécifiés.
machine, on a accès à un flux d'entrée et un flux de Par défaut, l'appel au constructeur est bloquant tant que
sortie, comme si l'on travaillait avec un fichier. la connexion TCP n'est pas établie.

La communication par socket est souvent comparée aux Une fois la connexion établie, il est possible de
communications humaines. On distingue ainsi deux récupérer le flux d'entrée et le flux de sortie de la
modes de communication : connexion TCP vers le serveur au moyen des méthodes
:
• Le mode connecté (comparable à une
communication téléphonique), utilisant le • public InputStream getInputStream () throws
protocole TCP. Dans ce mode de IOException
communication, une connexion durable est
établie entre les deux processus, de telle façon
1
 • public OutputStream getOutputStream ()
throws IOException
package test;
Il est alors possible d'echanger des données avec le import java.io.*;
serveur au moyen de toutes les primitives de lecture et import java.net.*;
d'écriture des différentes classes du package java.io.
public class SmtpClient {
Par défaut les primitives de lecture, tel que read(), sont public static void main(String argv[]) throws Exception {
bloquantes tant que rien n'est lisible sur le flux. sendmail("aaa","[email protected]");
La primitive suivante permet de définir un temps }
maximal d'attente : static void sendmail(String message, String to) throws
Exception {
Socket s = new
public synchronized void setSoTimeout(int timeout)
Socket(InetAddress.getByName("pixel.univ-mlv.fr"),25);
throws SocketException
PrintStream output = new
PrintStream(s.getOutputStream());
Une fois la connexion terminée il est très important de output.println("HELO qqcvd.univ-mlv.fr\r");
fermer le flux d'entrée et le flux de sortie, mais aussi la output.println("MAIL FROM: \r");
socket au moyen de la méthode : output.println("RCPT TO:<" + to + ">\r");
output.println("DATA\r");
public synchronized void close() throws output.println(message);
IOException output.println("\r\n.\r");
}
Par défaut cette primitive n'est pas bloquante mais la
socket reste ouverte tant qu'il reste des paquets à }
envoyer (en paticulier le datagramme FIN).
La primitive suivante permet de définir un temps La classe ServerSocket
maximum d'attente avant de vraiment fermer la socket.
Cette classe est utilisée (comme son nom l'indique) pour
public void setSoLinger(boolean on, int val) throws créer une socket du coté serveur.
SocketException
La classe ServerSocket permet de créer un point de
Par défaut, les implémentations du protocole TCP communication, sur un port particulier, en attente de
essaye de remplir au maximum chaque paquet (Nagle connexions en provenance de clients. Contrairement à
algorithm) afin de diminuer le trafic réseau. Pour éviter la classe Socket elle n'ouvre pas de connexion.
ce comportement, ce qui est souvent souhaitable dans Pour créer un tel objet, il faut utiliser un des
le cas d'application interactives¸ une primitive est constructeurs suivants, où port correspond au port
disponible : d'attente et count au nombre maximum de connexions
en attente, non encore acceptées.
public void setTcpNoDelay(boolean on) throws
SocketException • public ServerSocket(int port) throws
IOException
D'autres méthodes sont également disponibles et en • public ServerSocket(int port, int
particulier : count)throws IOException
• public ServerSocket(int port,int count,
• public InetAddress getInetAddress () InetAddress locale) throws IOException
• public int getPort ()
• public InetAddress getLocalAddress () Une fois la socket créée, on attend les connexions de
• public int getLocalPort () clients avec la méthode bloquante :
• int getLocalPort ()
• public int getSoLinger() throws • public Socket accept() throws IOException
SocketException
• public synchronized int getSoTimeout() Il est possible de spécifier un temps maximal d'attente.
throws SocketException Pour cela il faut appeler la méthode suivante avant
• public boolean getTcpNoDelay() throws l'appel à accept() :
SocketException
public synchronized void setSoTimeout(int timeout)
Remarque : une applet peut (pour des questions de throws SocketException
sécurité) se connecter uniquement à la machine depuis
laquelle elle a été chargée.
La méthode accept() retourne un nouvel objet de la
classe Socket qui est connecté avec un client particulier,
celui qui a demandé la connexion. Il est alors possible
Exemple :

2
de récupérer le flôt d'entrée et de sortie comme pour la // ServeurEcho.java
socket du client.
import java.io.*;
Exemple : import java.net.*;
class ServeurEcho {
public class DaytimeServeur { static int port =5555;
public static void main(String argv[]) throws Exception { public static void main(String [] argv) {
ServerSocket s = new ServerSocket(0); try {
System.out.println(s.getLocalPort()); // On crée une socket serveur (port passé en
while(true) { // argument)
Socket serviceSocket = s.accept(); //ServerSocket s_ecoute = new
PrintStream output = new ServerSocket(Integer.valueOf (argv[0]).intValue());
PrintStream(serviceSocket.getOutputStream()); ServerSocket s_ecoute = new ServerSocket(port);
output.println(new Date()); System.out.println("Serveur démarré sur la socket
serviceSocket.close(); d'écoute " + s_ecoute);
} // Attente d'une connexion
} Socket s_service = s_ecoute.accept();
// Une connexion a été ouverte
System.out.println("Ouverture de la connexion sur la
}
socket de service " + s_service);
// On crée un flot d'entrée et un de sortie
D'autres méthodes de manipulation sont également // (compatible JDK 1.1 uniquement)
disponibles : // flot d’entrée pour lire le texte provenant du client

• public void close() throws IOException

• public int getLocalPort()
• public InetAddress getInetAddress() DataInputStream entree = new DataInputStream (new
• public synchronized int getSoTimeout() BufferedInputStream (s_service.getInputStream()));
throws IOException
// flot de sortie pour envoyer le texte au client

PrintStream sortie = new PrintStream ( new

BufferedOutputStream(s_service.getOutputStream()));

// On boucle sur l'echo

while (true) {
// On lit une ligne en entrée
String buff = entree.readLine();
// On quitte si c'est égal à "FIN" : communication
terminée
if (buff.equals("FIN")) break;
// On renvoie l'echo au client
sortie.println(buff);
sortie.flush();
}
// Le client s'est déconnecté
System.out.println("Fermeture de la connexion...");
// On ferme la socket de service
s_service.close();
}
catch (Exception e) { return;}
}
}

Nous allons introduire les principales notions liées à la Analysons cet exemple. Tout d'abord, on importe les
programmation d'un client et d'un serveur TCP en Java, classes du package dans lequel sont définies les
en prenant l'exemple d'un serveur echo c'est à dire qui sockets, java.net, ainsi que celui correspondant aux
renvoie le texte envoyé par un client. Nous présenterons classes gérant les entrées/sorties, java.io.
ensuite un client utilisant ce serveur.
On crée ensuite une socket serveur, dite socket
Voici le source du serveur echo : d'écoute, sur le port indiqué sur la ligne de commande.
Ensuite, on attend la réception d'une demande de

3
connexion sur cette socket, via la méthode bloquante
accept(). Cette méthode renvoie une nouvelle socket,
dite socket de service, via laquelle le serveur et le client
vont pouvoir dialoguer.
Etudions ce source. Dans la fonction main(), on crée un
objet de type InetAddress qui va contenir l'adresse IP de
Nous définissons ensuite deux flots, l'un en entrée et la machine sur laquelle tourne le serveur. Ici, on
l'autre en sortie, avant d'entrer dans une boucle infinie suppose que le client et le serveur sont sur la même
qui constitue le cœur du serveur echo : elle copie le machine, on indique donc l'adresse de loopback, via la
texte reçu du client dans une chaîne et le renvoie tel méthode getByName(). On crée ensuite une socket de
quel au client. La communication se termine quand le communication vers le serveur, en spécifiant comme
client envoie la chaîne "FIN" au serveur. Précisons que numéro de port celui indiqué sur la ligne de commande.
la méthode flush() de la classe PrintWriter a pour effet Bien sûr, cela doit être le même numéro que pour le
d'envoyer immédiatement le texte voulu sur la socket. serveur.

Voyons maintenant le source du client correspondant : Ensuite, en crée trois flots, deux en entrée (un pour la
saisie au clavier, l'autre pour lire la réponse du serveur)
// ClientEcho.java et un en sortie (pour envoyer le texte au serveur).

import java.io.*; Nous entrons alors dans une boucle, telle que celle que
import java.net.*; nous avions créée pour le serveur, dans laquelle
class ClientEcho { s'effectuent trois opération successives :
static int port =5555;
public static void main (String argv[]) { 1. lecture de la chaîne à envoyer, à partir du
try { clavier (
// On crée un objet InetAdress sur
// l'interface de loopback
String buff = saisie.readLine();),
InetAddress adr =
InetAddress.getByName("127.0.0.1");
// On crée une socket 1. envoi de cette chaîne au serveur, sauf si elle est
// Socket s = new Socket (adr, Integer.valueOf égale à "FIN", signifiant que l'on veut fermer la
(argv[0]).intValue()); connexion avec le serveur (
Socket s = new Socket (adr, port);
Socket s = new Socket (“127.0.0.1”, port); sortie.println(buff);)
System.out.println("Socket crée");
// On crée 2 flots d'entrée et un de sortie 2. lecture de l'écho envoyé par le serveur (
// flot d’entrée pour la saisie
DataInputStream saisie =new DataInputStream(new String buff2 = entree.readLine();) et affichage de
BufferedInputStream (System.in)); celui-ci à l'écran.
// flot d’entrée pour lire la réponse du serveur
DataInputStream entree = new DataInputStream (new
Enfin, on ferme la socket quand on sort de la boucle.
BufferedInputStream (s.getInputStream()));
// flot de sortie pour envoyer le texte au serveur
PrintStream sortie = new PrintStream ( new Nous n'en dirons pas plus sur les sockets, il faut
BufferedOutputStream(s.getOutputStream())); cependant noter qu'un serveur réel aurait utilisé des
// On envoie du texte au serveur et on threads afin de pouvoir gérer simultanément plusieurs
// affiche l'echo reçu connexions (ce qui n'est pas le cas pour l'exemple que
while (true) { nous avons pris). Voyons maintenant comment Java
// Saisie du texte à envoyer au serveur gère les URL.
System.out.println("Texte ? ");
String buff = saisie.readLine(); Exemple 2 : Construction d'une application (applet) de
// Si on entre "FIN", on quitte lecture automatique de l'heure
if (buff.equals("FIN")) break;
// On envoie le texte saisi au serveur Classe Serveur
sortie.println(buff);
sortie.flush();
import java.net.* ;
// On affiche l'écho du serveur
import java.io.* ;
String buff2 = entree.readLine();
public class ServeurExample {
System.out.println(buff2);
}
public static void main(String [] args) {
// On ferme la socket : fermer la connexion au serveur
ServerSocket srv ;
s.close();
int port = 5555 ;
}
try {
catch (Exception e) { return; };
srv = new ServerSocket(port) ;
}
System.out.println("Serveur Ok") ;
}
while ( true ) {
4
 System.out.println("En attente") ; catch (IOException ioe) {
Socket connexion = srv.accept() ; bRun = false ;
System.out.println("Connexion") ; System.out.println(ioe.toString()) ; } ;
InputStream is = connexion.getInputStream() ; try {
DataInputStream dis = sleep(1000) ; }
new DataInputStream(is) ; catch (Exception e) { } ; }
String s = dis.readUTF() ; }
System.out.println(s) ;
connexion.close() ; } } }
catch(IOException e) { }
}
}
3. Les sockets UDP
CLIENT :
Le protocole UDP offre un service non connecté et non
//import java.applet.Applet ; fiabilisé. Les données peuvent être perdues, dupliquées
//import java.awt.* ; ou délivrées dans un ordre différent de leur ordre
import java.net.* ; d’émission.

public class Exemple { Le fonctionnement est ici symétrique. Chaque processus

crée un socket et l’utilise pour envoyer ou attendre et
public static void main (String v[]) { recevoir des données.
try{
InetAddress host=null;
Voici le schéma d'une communication en mode non
host = InetAddress.getByName("127.0.0.1");
connecté:
ThreadExemple te = new ThreadExemple(host) ;
te.start() ;
}
catch (Exception e ) { System.out.println(" ERROR
Example 3");}

}
}

ThreadExemple.java

import java.net.* ;
import java.io.* ;

public class ThreadExemple extends Thread {

InetAddress host; Pour utiliser le protocole de transport UDP, il est
nécessaire en Java de manipuler deux classes
public ThreadExemple(InetAddress s) { DatagramPacket pour représenter les datagrammes
UDP qui sont échangés entre les machines. et
host = s ; DatagramSocket
}

public void run() { La classe DatagramPacket

boolean bRun = true ;
while ( bRun) { Cette classe permet de créer des objets qui contiendront
Socket s ; les données envoyées ou reçues ainsi que l'adresse de
int port = 5555 ; destination ou de provenance du datagramme.
try {
s = new Socket(host,port) ; Deux constructeurs sont disponibles, un pour les
InputStream is = s.getInputStream() ; paquets à recevoir, l'autre pour les paquets à envoyer.
DataInputStream ois = new DataInputStream(is) ;
int hr = ois.readInt() ; • public DatagramPacket(byte buffer[], int
int mn = ois.readInt() ; taille)
int sc = ois.readInt() ;
int ml = ois.readInt() ;
Construit un objet pour recevoir un datagramme.
System.out.println("Heure sur "+host+
Le paramètre buffer correspond à la zone où
" : "+hr+":"+mn+ ":"+sc+":"+ml) ;
doit être stocké le datagramme reçu et le
ois.close() ; }
paramètre taille correspond à la taille maximale
catch (UnknownHostException uhe) {
des datagrammes à recevoir.
bRun = false ;
System.out.println(uhe.toString()) ; }
5
 • public DatagramPacket(byte buffer[], int • public DatagramSocket () throws
taille, InetAddress adresse, int port) SocketException

Construit un objet pour envoyer un datagramme. Crée un objet de type socket et l'attache à un
Le paramètre buffer correspond à la zone où est port disponible de la machine locale. Ce
stocké le datagramme à envoyer, le paramètre constructeur doit être utilisé dans les clients
taille correspond à la taille du datagramme à pour lesquels le port d'attachement n'a pas
envoyer, adresse correspond à l'adresse de la besoin d'être connu.
machine à qui envoyer le datagramme et port
sur quel port UDP. • public DatagramSocket (int port) throws
SocketException
Des méthodes sont disponibles pour manipuler de tels
objets : Crée un objet de type socket et l'attache au port
• public synchronized InetAddress getAddress UDP local passé en paramètre. En particulier,
() ce constructeur doit être utilisé dans les
Retourne l'adresse stockée dans le paquet. serveurs pour lesquels le port d'attachement a
• public synchronized int getPort () besoin d'être fixé préalablement afin qu'il soit
Retourne le port stocké dans le paquet. connu des clients.
• public synchronized byte[] getData ()
Retourne les données stockées dans le paquet. • public DatagramSocket(int port, InetAddress
• public synchronized int getLength () laddr) throws SocketException
Retourne la taille des données stockées dans le
paquet.
Crée un objet de type socket, l'attache au port
• public synchronized void
UDP local passé en paramètre et à une adresse
setAddress(InetAddress iaddr) spécifique de la machine locale. Ce constructeur
Modifie ou affecte l'adresse de destination. n'est utile que si la machine locale dispose de
• public synchronized void setPort(int iport) plusieurs adresses Internet.
Modifie ou affecte le port de destination.
• public synchronized void setData(byte ibuf[])
Une fois la socket (objet de type DatagramSocket) créée
Modifie ou affecte la référence de la zone
et attachée à un port
contenant les données.
particulier de la machine locale, il est possible d'envoyer
• public synchronized void setLength(int
et de recevoir des datagrammes,
ilength)
via cette socket, au moyen des méthodes suivantes :
Modifie ou affecte la taille de la zone contenant
les données.
• public void send(DatagramPacket data)
Exemple d’utilisation : throws IOException

String message = "Bonjour le monde!"; 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
byte[] tampon = message.getBytes();
dans la variable data.
InetAddress adresse =
• public synchronized void
InetAddress.getByName("marine.edu.ups-tlse.fr");
receive(DatagramPacket data) throws
IOException
DatagramPacket datagramme = new
DatagramPacket(tampon, tampon.length, adresse, 7);
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
La classe DatagramSocket à recevoir. Si le message est trop long pour être
stocké, celui-ci est tronqué, et le reste est perdu.
Cette classe permet de créer des sockets UDP qui Il n'est donc pas possible de recevoir des
permettent d'envoyer et de recevoir des datagrammes messages dont on ne connait pas
UDP. préalablement la taille.

Avant toute communication en mode UDP il est Il est possible de spécifier un délai d'attente maximal en
nécessaire de créer une socket aussi bien du coté client reception. Pour cela, il faut positionner une variable de
que du coté serveur. Pour cela Java propose trois timeout sur la socket au moyen de la méthode :
constructeurs :
• public synchronized void setSoTimeout(int
timeout) throws SocketException
6
 Une valeur de 0 (zéro) correspond à ne pas {
avoir de timeout. final static int taille = 1024;
final static byte buffer[] = new byte[taille];
D'autres méthodes sont disponibles pour manipuler ces
sockets : public static void main(String argv[]) throws Exception
{
InetAddress serveur = InetAddress.getByName(argv[0]);
• public void close ()
int length = argv[1].length();
byte buffer[] = argv[1].getBytes();
Ferme la socket et libère les ressources qui lui DatagramPacket dataSent = new
sont associées. La socket ne pourra plus être DatagramPacket(buffer,length,serveur,ServeurEcho.port)
utilisée ni pour envoyer, ni pour recevoir des ;
datagrammes. DatagramSocket socket = new DatagramSocket();

socket.send(dataSent);
• public int getLocalPort ()
DatagramPacket dataRecieved = new
Retourne le port d'attachement de la socket. DatagramPacket(new byte[length],length);
socket.receive(dataRecieved);
System.out.println("Data recieved : " + new
• public synchronized int getSoTimeout()
String(dataRecieved.getData()));
throws SocketException
System.out.println("From : " +
dataRecieved.getAddress() + ":" +
Retourne la valeur courante du timeout associé dataRecieved.getPort());
à la socket. }
}
Exemple :

Dans cet exemple nous créons deux classes : 3.2. La classe MulticastSocket

• une classe ServeurEcho qui attend une chaîne Cette classe permet d’utiliser le multicasting IP pour
de caractères et la retourne envoyer des datagrammes UDP à un ensemble de
• une classe ClientEcho qui envoye une chaîne machines repéré grâce à une addresse multicast (classe
de caractères, attend que le serveur la lui D dans IP version 4 : de 224.0.0.1 à 239.255.255.255).
retourne et l'affiche.
3.2.1. Constructeurs
import java.io.*;
import java.net.*; Les constructeurs de cette classe sont identiques à ceux
de la classe DatagramSocket.
class ServeurEcho
{ 3.2.2. Abonnement/résiliation
final static int port = 8532;
final static int taille = 1024;
final static byte buffer[] = new byte[taille]; Pour pouvoir recevoir des datagrammes UDP envoyés
grâce au multicasting IP il faut s’abonner à une adresse
public static void main(String argv[]) throws Exception multicast (de classe D pour IP version 4). De même
{ lorsqu’on ne souhaite plus recevoir des datagrammes
DatagramSocket socket = new DatagramSocket(port); UDP envoyés à une adresse multicast on doit indiquer la
while(true) résiliation de l’abonnement.
{
DatagramPacket data = new public void
DatagramPacket(buffer,buffer.length); joinGroup(InetAddress adresseMulticast) throws
socket.receive(data); IOException
System.out.println(data.getAddress());
socket.send(data); Cette méthode permet de s’abonner à l’adresse
} multicast donnée.
}
} Note : un même socket peut s’abonner à plusieurs
import java.io.*; adresses multicast simultanément. D’autre part il n’est
import java.net.*; pas nécessaire de s’abonner à une adresse multicast si
on veut juste envoyer des datagrammes à cette
adresse.

public class ClientEcho

7
Une IOException est générée si l’adresse n’est pas une DatagramPacket(msg.getBytes(), msg.length(),
adresse multicast ou si il y a un problème de groupe, 50000);
configuration réseau. // envoie le datagramme a tout le monde
s.send(envoi);
public void while (true) {
leaveGroup(InetAddress adresseMulticast) throws byte[] tampon = new byte[1024];
IOException DatagramPacket reception = new DatagramPacket(buf,
buf.length);
Cette méthode permet de résilier son abonnement à // attends les réponses
l’adresse multicast donnée. s.receive(reception);
String texte=new String(tampon, 0,
reception.getLength());
Une IOException est générée si l’adresse n’est pas une System.out.println("Reception de la machine "+
adresse multicast, si la socket n’était pas abonnée à reception.getAddress().getHostName()+
cette adresse ou si il y a un problème de configuration " sur le port" +reception.getPort()+":\n"+ texte);
réseau. }
// si la boucle n’était pas infinie on pourrais écrire:
3.2.3. Choix du TTL // s.leaveGroup(groupe);
}
Dans les datagrammes IP se trouve un champ }
spécifique appelé TTL (Time To Live – durée de
vie) qui est normalement initialisé à 255 et 4. Les URL
décrémenté par chaque routeur que le
datagramme traverse. Lorsque ce champ atteint
la valeur 0 le datagramme est détruit et une Java permet d'utiliser des URL, lors de la désignation
erreur ICMP est envoyé à l’émetteur du d'une ressource, ce qui simplifie grandement la
datagramme. Cela permet d’éviter que des programmation de certaines applications. Regardons
datagrammes tournent infiniment à l’intérieur comment ces URL sont utilisées en Java, en prenant
d’un réseau IP. l'exemple d'un programme qui récupère un fichier sur un
serveur web et qui en affiche le contenu à l'écran :
Le multicasting IP utilise ce champ pour limiter la portée
de la diffusion. Par exemple avec un TTL de 1 la // GetURL.java
diffusion d’un datagramme est limitée au réseau
local. import java.io.*;
public int getTimeToLive() throws IOException import java.net.*;
public void setTimeToLive(int ttl) throws class GetURL {
IOException public static void main (String [] argv) {
try {
URL url = new URL (argv[0]);
Ces méthodes permettent la consultation et la
URLConnection uc = url.openConnection();
modification du champ TTL qui sera écrit dans les
// On crée un flot d'entrée
datagrammes envoyés par ce socket.
DataInputStream entree = new DataInputStream (new
BufferedInputStream (uc.getInputStream()));
Exemple de programme qui envoie et reçoit des // On récupère le document
datagrammes avec le multicasting IP System.out.println("Contenu du document " + argv[0] + ":");
String buff = " ";
import java.net.*; while (buff != null) {
import java.io.*; buff = entree.readLine();
class MulticastingIP System.out.println(buff);
{ }
public static void main(String argv[]) } catch (Exception e) { return ; }
throws SocketException, IOException }}
{
String msg = "Bonjour le monde!"; Cette fois-ci, on ne définit plus d'objet socket mais un
// on traveillera avec l’adresse multicast 228.5.6.7 objet URL, associé à une URL (passée en argument).
InetAddress groupe = Ensuite, on tente de se connecter au serveur spécifié
InetAddress.getByName("228.5.6.7"); dans cette URL (URLConnection uc =
// crée le socket utilisé pour émettre et recevoir les url.openConnection()). On ouvre après un flot de lecture
datagrammes sur l'URL, puis on entre dans une boucle qui copie les
// il utilisera le port 50000 données envoyées par le serveur à l'écran.
MulticastSocket s = new MulticastSocket(50000);
// s’abonne à l’adresse IP multicast
Cet exemple très simple montre comme il est facile
s.joinGroup(groupe);
d'utiliser les URL pour réaliser des applications de base.
// crée l’objet qui stocke les données du datagramme à
C'est une intéressante alternative aux sockets que Sun
envoyer
nous propose.
DatagramPacket envoi = new
8
ENI Fianarantsoa