Programmation réseau en Java : des sockets aux NIO et WebSockets

Pourquoi la programmation réseau en Java est-elle un super-pouvoir ?

Imaginez : vous écrivez du code, et soudain votre programme commence à communiquer avec un autre programme à l'autre bout du monde. Il envoie des requêtes, reçoit des réponses, synchronise des données — et tout cela en quelques millisecondes. Ce n'est pas de la magie, c'est la programmation réseau en Java. Si vous voulez créer non seulement des utilitaires locaux, mais de véritables systèmes distribués, des chats, des jeux en ligne ou des services REST — la programmation réseau est indispensable.

Java offre pour cela une boîte à outils puissante : des classiques Socket et ServerSocket au performant Java NIO (Non-blocking I/O) et aux modernes WebSockets. Dans cet article, nous allons explorer ces trois approches, écrire du code concret et comprendre comment choisir le bon outil pour votre tâche. C'est parti !

1. Les sockets classiques : un chat TCP « fait maison »

Commençons par les fondamentaux. Les sockets en Java sont le point d'entrée dans le monde TCP/IP. Le serveur crée un ServerSocket, écoute un port, accepte les connexions. Le client crée un Socket et se connecte au serveur. Simple comme bonjour.

Écrivons un serveur d'écho simple

Le serveur reçoit un message du client et le renvoie (écho). Le code est minimal, mais illustre l'essentiel :

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

public class EchoServer {    public static void main(String[] args) {        try (ServerSocket serverSocket = new ServerSocket(12345)) {            System.out.println("Serveur démarré sur le port 12345...");            Socket clientSocket = serverSocket.accept(); // bloqué jusqu'à la connexion            System.out.println("Client connecté : " + clientSocket.getInetAddress());

            BufferedReader in = new BufferedReader(                new InputStreamReader(clientSocket.getInputStream()));            PrintWriter out = new PrintWriter(                clientSocket.getOutputStream(), true);

            String inputLine;            while ((inputLine = in.readLine()) != null) {                System.out.println("Reçu : " + inputLine);                out.println("Écho : " + inputLine);                if (inputLine.equalsIgnoreCase("exit")) break;            }        } catch (IOException e) {            e.printStackTrace();        }    }}

Et voici le client qui envoie les messages :

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

public class EchoClient {    public static void main(String[] args) throws IOException {        Socket socket = new Socket("localhost", 12345);        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);        BufferedReader in = new BufferedReader(            new InputStreamReader(socket.getInputStream()));        BufferedReader stdIn = new BufferedReader(            new InputStreamReader(System.in));

        String userInput;        System.out.println("Entrez un message (exit pour quitter) :");        while ((userInput = stdIn.readLine()) != null) {            out.println(userInput);            System.out.println("Réponse du serveur : " + in.readLine());            if (userInput.equalsIgnoreCase("exit")) break;        }        socket.close();    }}

Qu'est-ce qui est important ici ? Les méthodes accept() et readLine() bloquent le thread. Cela signifie que pendant qu'un client communique, les autres attendent. La solution est le multithreading.

Serveur multithread : gérer plusieurs clients

Pour chaque nouvelle connexion, nous créons un thread séparé. Nous utilisons un pool de threads ExecutorService pour ne pas multiplier les threads inutilement :

import java.io.*;import java.net.*;import java.util.concurrent.*;

public class MultiThreadedServer {    private static final int PORT = 12345;    private static final ExecutorService threadPool = Executors.newFixe