Introduction au réseau en Java

Le réseau, c'est la façon dont un programme Java communique avec un autre programme — dans la même pièce ou à l'autre bout du monde. Le JDK fournit une pile complète et prête à l'emploi dans deux packages : le classique java.net (URLs, sockets, adresses) et le moderne java.net.http (le HttpClient introduit dans Java 11). Cette partie du livre parcourt cette pile depuis les fonctionnalités de haut niveau jusqu'aux sockets bruts.

Les couches, de la plus haute à la plus basse

Les API réseau de Java forment une échelle. Choisissez l'échelon le plus haut qui répond au besoin :

Échelon	API	À utiliser pour
Le plus haut	`HttpClient` (`java.net.http`)	HTTP/HTTPS moderne : appels REST, téléchargements, asynchrone
	`URL` / `URLConnection` / `HttpURLConnection`	HTTP hérité et autres protocoles URL
	`Socket` / `ServerSocket`	Protocoles TCP personnalisés, client/serveur maison
Le plus bas	`DatagramSocket`	Messagerie UDP sans connexion
Support	`InetAddress`	Résolution et représentation des adresses IP

La règle générale : si vous appelez une API HTTP, utilisez HttpClient. Ne descendez aux sockets que lorsque vous utilisez un protocole non-HTTP ou que vous construisez votre propre serveur.

TCP vs. UDP

Deux protocoles de transport sous-tendent presque tout :

TCP (Socket, ServerSocket) est une connexion : fiable, ordonnée, basée sur les flux. Les octets que vous écrivez arrivent intacts et dans l'ordre, ou vous obtenez une erreur. HTTP, les bases de données et la plupart des protocoles applicatifs s'appuient sur TCP.
UDP (DatagramSocket) est sans connexion : vous envoyez des paquets indépendants (« datagrammes ») sans établissement de connexion, sans ordre et sans garantie de livraison. Il échange la fiabilité contre une faible latence — utilisé pour DNS, la diffusion vidéo et les jeux.

Client vs. serveur

Un client initie une connexion vers une adresse et un port connus. Un serveur se lie à un port et attend d'accepter les connexions entrantes. La même classe Socket représente la connexion active des deux côtés ; l'asymétrie réside uniquement dans le fait de savoir qui commence la conversation. Les chapitres suivants construisent les deux côtés.

Bloquant par défaut

Les API classiques de java.net sont bloquantes : socket.getInputStream().read() met en attente le thread appelant jusqu'à l'arrivée des données, et serverSocket.accept() se met en attente jusqu'à ce qu'un client se connecte. C'est simple à comprendre, mais cela implique un thread par connexion. (java.nio avec ses canaux et les threads virtuels répondent aux problèmes de montée en charge ; cette partie reste sur les API bloquantes, qui sont le bon point de départ.)

Un exemple concret : toute la pile dans un seul fichier

Pour rendre les éléments concrets, ce programme démarre un petit serveur HTTP sur l'interface de bouclage, puis l'appelle avec le HttpClient moderne — un aller-retour complet client/serveur dans une seule JVM, sans réseau externe nécessaire.

java— editable, runs on the server

import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;

public class NetworkingIntroDemo {
  public static void main(String[] args) throws Exception {
    // 1. A minimal server, bound to loopback on an OS-chosen (port 0) port
    HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
    server.createContext("/hello", exchange -> {
      byte[] body = "Hello from the server".getBytes(StandardCharsets.UTF_8);
      exchange.sendResponseHeaders(200, body.length);
      try (OutputStream os = exchange.getResponseBody()) { os.write(body); }
    });
    server.start();
    int port = server.getAddress().getPort();
    System.out.println("server listening on 127.0.0.1:" + port);

// 2. The client: build a request and send it with HttpClient
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("http://127.0.0.1:" + port + "/hello"))
        .GET()
        .build();
    HttpResponse<String> response =
        client.send(request, HttpResponse.BodyHandlers.ofString());

System.out.println("status      : " + response.statusCode());
    System.out.println("body        : " + response.body());
    System.out.println("http version: " + response.version());

server.stop(0);
    System.out.println("server stopped");
  }
}

Ce qu'il faut retenir de l'exécution :

Un client et un serveur fonctionnels tiennent dans un seul fichier court. Les applications réelles les séparent entre des machines, mais l'API est identique — HttpServer a accepté une connexion et HttpClient en a ouvert une, se rejoignant via TCP sur l'interface de bouclage (127.0.0.1). C'est la forme de tout programme réseau : un côté attend, l'autre appelle.
Se lier au port 0 laisse l'OS choisir un port libre, que server.getAddress().getPort() retourne ensuite. Coder en dur un port risque de produire « address already in use » ; le port 0 est l'astuce standard pour les tests et démos qui ont simplement besoin d'un port.
Le client n'a jamais touché directement un socket. HttpClient a géré la connexion, la ligne de requête HTTP, les en-têtes et l'analyse de la réponse — c'est la valeur de monter à l'échelon le plus haut de l'échelle. Les chapitres sur les sockets montreront ce qu'il a masqué.
La réponse contenait des métadonnées structurées : un statusCode() (200), un body() et une version(). Les réponses HTTP sont plus que du texte ; le client les a modélisées comme un objet HttpResponse typé pour que vous lisiez des champs plutôt que d'analyser un flux.
server.stop(0) a libéré le port. Les ressources réseau — sockets, ports serveur, connexions — sont des descripteurs OS rares ; chaque chapitre de cette partie les ferme explicitement (ou avec try-with-resources) pour éviter les fuites.

Ce que couvre le reste de cette partie

Les chapitres à venir descendent l'échelle :

La classe URL et URLConnection / HttpURLConnection — analyse des URLs et l'API de connexion héritée.
Le HttpClient moderne en profondeur — requêtes HTTP/2 synchrones et asynchrones.
Le TCP brut avec Socket et ServerSocket — construire votre propre client et serveur.
L'UDP sans connexion avec DatagramSocket.
La résolution d'adresses avec InetAddress.

Le prochain chapitre commence par l'objet réseau le plus familier de tous : l'URL.

Pratique

Vous écrivez un service Java qui appelle une API REST tierce via HTTPS et avez besoin de requêtes synchrones et asynchrones sur un JDK moderne. Quelle API est le premier choix le plus approprié ?

'java.net.http.HttpClient', l'API HTTP moderne de haut niveau qui prend en charge 'send' synchrone, 'sendAsync' asynchrone, HTTP/2 et HTTPS sans configuration supplémentaireUne connexion 'Socket' brute sur le port 443, en écrivant manuellement la ligne de requête HTTP et les en-têtes'DatagramSocket', car UDP est plus rapide et les API REST sont sans état'ServerSocket', puisqu'appeler une API signifie accepter la connexion du serveur API