Comme pour les threads, Java possède en standard une API permettant de programmer des applications réseau, en utilisant des sockets. Dans ce chapitre, nous traiterons des sockets TCP ainsi que des URL car Java possède plusieurs classes spécialisées dans ce domaine.

Une socket est une notion très répandue en programmation réseau, en particulier sous UNIX. Il s'agit en fait d'un point de communication entre un processus et un réseau. Un processus client et un processus serveur, lorsqu'ils communiquent, ouvrent donc chacun une socket. C'est le système d'exploitation qui alloue ces sockets sur demande d'une application. A chaque socket est associé un port de connexion. Ces numéros de port sont uniques sur un système donné, une application pouvant en utiliser plusieurs (un serveur par exemple exploite une socket par client connecté). Certains numéros sont réservés pour des applications (ou protocoles) précises, par exemple le port 80 est réservé aux serveurs web (HTTP). Ces ports réservés ont un numéro inférieur à 1024.

Une connexion est identifiée de façon unique par la donnée de deux couples, une adresse IP et un numéro de port, un pour le client et un autre pour le serveur. Il est important de noter qu'un dialogue client/serveur n'a pas forcément lieu via un réseau. Il est en effet possible de faire communiquer un client et un serveur sur une même machine, via ce qu'on appelle l'interface de loopback, représentée par convention par l'adresse IP 127.0.0.1.

Dans ce chapitre, nous allons voir comment manipuler des sockets TCP et des URL. Nous n'aborderons pas la programmation d'applications en mode non connecté, via UDP.

Java distingue les sockets clientes des sockets serveurs en deux classes, respectivement Socket et ServerSocket, contenues dans le package java.net. Nous allons introduire les principales notions liées à la programmation d'un client et d'un serveur TCP en Java, en prenant l'exemple d'un serveur echo c'est à dire qui renvoie le texte envoyé par un client. Nous présenterons ensuite un client utilisant ce serveur.

Voici le source du serveur echo :

// ServeurEcho.java

//

import java.io.*;

import java.net.*;

class ServeurEcho {

public static void main(String [] argv) {

try {

// On crée une socket serveur (port passé en

// argument)

ServerSocket s_ecoute = new ServerSocket(Integer.valueOf (argv[0]).intValue());

System.out.println("Serveur démarré sur la socket 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

// (compatible JDK 1.1 uniquement)

BufferedReader entree = new BufferedReader (new InputStreamReader ( s_service.getInputStream()));

PrintWriter sortie = new PrintWriter ( new OutputStreamWriter ( 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"

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;}

}

}

Analysons cet exemple. Tout d'abord, on importe les classes du package dans lequel sont définies les sockets, java.net, ainsi que celui correspondant aux classes gérant les entrées/sorties, java.io.

On crée ensuite une socket serveur, dite socket d'écoute, sur le port indiqué sur la ligne de commande. Ensuite, on attend la réception d'une demande de 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.

Nous définissons ensuite deux flots, l'un en entrée et l'autre en sortie, avant d'entrer dans une boucle infinie qui constitue le cœur du serveur echo : elle copie le texte reçu du client dans une chaîne et le renvoie tel quel au client. La communication se termine quand le client envoie la chaîne "FIN" au serveur. Précisons que la méthode flush() de la classe PrintWriter a pour effet d'envoyer immédiatement le texte voulu sur la socket.

Voyons maintenant le source du client correspondant :

// ClientEcho.java

//

import java.io.*;

import java.net.*;

class ClientEcho {

public static void main (String argv[]) {

try {

// On crée un objet InetAdress sur

InetAddress adr = InetAddress.getByName("127.0.0.1");

// On crée une socket

Socket s = new Socket (adr, Integer.valueOf (argv[0]).intValue());

System.out.println("Socket crée");

// On crée 2 flots d'entrée et un de sortie

DataInputStream entree = new DataInputStream (new BufferedInputStream (s.getInputStream()));

PrintStream sortie = new PrintStream ( new BufferedOutputStream(s.getOutputStream()));

// On envoie du texte au serveur et on

// affiche l'echo reçu

while (true) {

// Saisie du texte à envoyer au serveur

// Si on entre "FIN", on quitte

// On affiche l'écho du serveur

}

// On ferme la socket

s.close();

}

}

}

Etudions ce source. Dans la fonction main(), on crée un objet de type InetAddress qui va contenir l'adresse IP de la machine sur laquelle tourne le serveur. Ici, on suppose que le client et le serveur sont sur la même machine, on indique donc l'adresse de loopback, via la méthode getByName(). On crée ensuite une socket de communication vers le serveur, en spécifiant comme numéro de port celui indiqué sur la ligne de commande. Bien sûr, cela doit être le même numéro que pour le serveur.

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) et un en sortie (pour envoyer le texte au serveur).

Nous entrons alors dans une boucle, telle que celle que nous avions créée pour le serveur, dans laquelle s'effectuent trois opération successives :

Enfin, on ferme la socket quand on sort de la boucle.

Nous n'en dirons pas plus sur les sockets, il faut cependant noter qu'un serveur réel aurait utilisé des threads afin de pouvoir gérer simultanément plusieurs connexions (ce qui n'est pas le cas pour l'exemple que nous avons pris). Voyons maintenant comment Java gère les URL.

Java permet d'utiliser des URL, lors de la désignation d'une ressource, ce qui simplifie grandement la programmation de certaines applications. Regardons comment ces URL sont utilisées en Java, en prenant l'exemple d'un programme qui récupère un fichier sur un serveur web et qui en affiche le contenu à l'écran :

// GetURL.java

//

import java.io.*;

import java.net.*;

class GetURL {

public static void main (String [] argv) {

try {

URL url = new URL (argv[0]);

URLConnection uc = url.openConnection();

// On crée un flot d'entrée

}

}

Cet exemple très simple montre comme il est facile d'utiliser les URL pour réaliser des applications de base. C'est une intéressante alternative aux sockets que Sun nous propose.

Avant de décrire AWT et de présenter les applets Java, étudions ce qu'on appelle les exceptions.