Maîtriser la programmation réseau Java : Construire des applications réseau robustes avec java.net

La programmation réseau désigne l'écriture de programmes s'exécutant sur plusieurs appareils (ordinateurs) connectés par un réseau.

Le package java.net des API J2SE fournit classes et interfaces pour la communication bas niveau, permettant de se concentrer sur la résolution du problème.

Support des deux protocoles réseau courants :

TCP (Transmission Control Protocol) : communication fiable entre deux applications. Utilisé sur IP → TCP/IP.
UDP (User Datagram Protocol) : sans connexion, envoi de paquets de données entre applications.

Deux sujets principaux :

Programmation par sockets : concept le plus utilisé en réseau, détaillé ci-dessous
Traitement d'URL : couvert séparément

Programmation par sockets (TCP)

Les sockets assurent la communication entre deux ordinateurs via TCP.

Le client crée un socket et tente de se connecter au serveur
Connexion établie → le serveur crée un objet socket
Client et serveur communiquent en lisant/écrivant sur le socket

Classes : java.net.Socket (socket), java.net.ServerSocket (écoute clients).

Étapes d'établissement d'une connexion TCP

Serveur instancie ServerSocket sur un port
Serveur appelle accept() : bloque jusqu'à connexion client
Client instancie Socket avec hôte et port
Constructeur Socket tente la connexion. Si succès → socket client prêt
accept() retourne nouveau socket serveur connecté au client

Communication via flux E/S : chaque socket a OutputStream et InputStream. Client OutputStream → Server InputStream, et vice-versa. TCP = bidirectionnel simultané.

Méthodes de ServerSocket

Utilisé par les serveurs pour obtenir un port et écouter les clients.

Constructeurs

Constructeur	Description
`ServerSocket(int port)`	Crée socket serveur lié au port. Exception si port déjà utilisé
`ServerSocket(int port, int backlog)`	backlog = file d'attente clients en attente
`ServerSocket(int port, int backlog, InetAddress addr)`	Lie à l'adresse IP locale spécifiée (serveurs multi-IP)
`ServerSocket()`	Socket non lié. Utiliser `bind()` plus tard

Si pas d'exception → application liée au port, prête pour clients.

Méthodes courantes

Méthode	Description
`getLocalPort()`	Port d'écoute (utile si port=0 → auto-assigné)
`accept()`	Bloque jusqu'à connexion client. Retourne nouveau Socket
`setSoTimeout(int timeout)`	Délai d'attente pour accept()
`bind(SocketAddress, int backlog)`	Lie le socket (si constructeur sans argument)

Méthodes de Socket

Représente le socket côté client et serveur. Client : instanciation directe. Serveur : retour de accept().

Constructeurs client

Constructeur	Description
`Socket(String host, int port)`	Connexion à hôte:port. Succès = connecté
`Socket(InetAddress host, int port)`	Identique, hôte via InetAddress
`Socket(String host, int port, InetAddress localAddr, int localPort)`	Connexion + socket local sur adresse/port spécifiques
`Socket(InetAddress host, int port, InetAddress localAddr, int localPort)`	Version InetAddress
`Socket()`	Non connecté. Utiliser `connect()` après

Méthodes utiles (client et serveur)

Méthode	Description
`connect(SocketAddress, int timeout)`	Connexion (si constructeur sans arg)
`getInetAddress()`	Adresse de l'ordinateur distant
`getPort()`	Port distant
`getLocalPort()`	Port local
`getRemoteSocketAddress()`	Adresse socket distant
`getInputStream()`	Flux entrée (connecté à sortie distant)
`getOutputStream()`	Flux sortie (connecté à entrée distant)
`close()`	Ferme le socket

Méthodes de InetAddress

Représente une adresse IP.

Méthode	Description
`getByAddress(byte[])`	InetAddress depuis IP brute
`getByAddress(String host, byte[])`	InetAddress depuis nom hôte + IP
`getByName(String host)`	IP depuis nom d'hôte
`getHostAddress()`	IP en format textuel
`getHostName()`	Nom d'hôte pour cette IP
`getLocalHost()`	Hôte local
`toString()`	IP en chaîne

Exemple : Client Socket


// GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {
    public static void main(String[] args) {
        String serverName = args[0];
        int port = Integer.parseInt(args[1]);
        
        try {
            System.out.println("Connexion à " + serverName + " sur le port " + port);
            Socket client = new Socket(serverName, port);
            System.out.println("Connecté à " + client.getRemoteSocketAddress());
            
            OutputStream outToServer = client.getOutputStream();
            DataOutputStream out = new DataOutputStream(outToServer);
            out.writeUTF("Bonjour depuis " + client.getLocalSocketAddress());
            
            InputStream inFromServer = client.getInputStream();
            DataInputStream in = new DataInputStream(inFromServer);
            System.out.println("Serveur dit : " + in.readUTF());
            
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Exemple : Serveur Socket


// GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
    private ServerSocket serverSocket;
    
    public GreetingServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        serverSocket.setSoTimeout(10000);
    }
    
    public void run() {
        while (true) {
            try {
                System.out.println("Attente client sur le port " + serverSocket.getLocalPort() + "...");
                Socket server = serverSocket.accept();
                System.out.println("Connecté à " + server.getRemoteSocketAddress());
                
                DataInputStream in = new DataInputStream(server.getInputStream());
                System.out.println(in.readUTF());
                
                DataOutputStream out = new DataOutputStream(server.getOutputStream());
                out.writeUTF("Merci de vous connecter à " + server.getLocalSocketAddress() + "\nAu revoir !");
                
                server.close();
            } catch (SocketTimeoutException s) {
                System.out.println("Délai d'attente dépassé !");
                break;
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }
        }
    }
    
    public static void main(String[] args) {
        int port = Integer.parseInt(args[0]);
        try {
            Thread t = new GreetingServer(port);
            t.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Compilation et exécution


$ javac GreetingServer.java GreetingClient.java
$ java GreetingServer 6066
En attente client sur le port 6066...

Dans un autre terminal :


$ java GreetingClient localhost 6066
Connexion à localhost sur le port 6066
Connecté à localhost/127.0.0.1:6066
Serveur dit : Merci de vous connecter à /127.0.0.1:6066
Au revoir !

Bonnes pratiques modernes

Utiliser try-with-resources pour fermer automatiquement sockets/flux
Préférer NIO.2 (AsynchronousSocketChannel) pour serveurs haute performance
Gérer les timeouts et erreurs réseau proprement
Pour applications réelles : frameworks (Netty, gRPC, Spring Boot) plutôt que sockets bruts

Sérialisation d'objets Java : Persistance et restauration d'objets Comment envoyer des e-mails en Java : Guide étape par étape

Java