Classe Java InetAddress | W3Docs Learn Java

Chaque connexion dans cette partie nécessite une adresse — un hôte et un port. java.net.InetAddress est la classe qui représente la partie hôte : une adresse IP, optionnellement associée à un nom d'hôte. C'est aussi la passerelle vers le DNS (Domain Name System), qui transforme un nom comme example.com en adresse numérique que le réseau utilise réellement pour router les paquets. Ce dernier chapitre sur le Networking couvre la création, la résolution et l'inspection des adresses. Les instances InetAddress que vous construisez ici sont celles que vous transmettez à un Socket, un ServerSocket ou un DatagramSocket pour établir une connexion.

Pas de constructeur public — utilisez les méthodes fabrique

Vous n'écrivez jamais new InetAddress(...). À la place :

InetAddress a = InetAddress.getByName("example.com");   // DNS lookup (or parse a literal)
InetAddress b = InetAddress.getByName("93.184.216.34"); // numeric literal: no DNS
InetAddress[] all = InetAddress.getAllByName("example.com"); // every address for a host
InetAddress lo = InetAddress.getLoopbackAddress();      // 127.0.0.1 / ::1, never fails
InetAddress me = InetAddress.getLocalHost();            // this machine's address
InetAddress c = InetAddress.getByAddress(new byte[]{10,0,0,1}); // from raw bytes

Distinction clé : getByName avec un nom d'hôte effectue une requête DNS (qui peut être lente ou lever une UnknownHostException en mode hors ligne) ; avec un littéral numérique, il se contente de le parser, sans réseau. getByAddress construit une adresse à partir d'octets bruts sans aucune résolution.

Quand aurais-je besoin de ceci ? Chaque fois que vous devez résoudre un nom avant de vous connecter, valider ou classifier une adresse (loopback, privée, multicast), ou conserver une adresse en cache pour éviter des résolutions DNS répétées dans un chemin critique. Un assistant de plus haut niveau comme la classe URL résout les hôtes en coulisses ; InetAddress est la couche à laquelle vous descendez quand vous avez besoin de l'adresse elle-même.

IPv4 et IPv6

InetAddress est le supertype commun ; les instances concrètes sont Inet4Address (32 bits, 93.184.216.34) ou Inet6Address (128 bits, ::1). getAddress() renvoie les octets bruts (4 ou 16), et getHostAddress() renvoie la forme textuelle canonique. Le code devrait traiter les deux familles de manière uniforme via le type InetAddress.

Inspecter une adresse

Des prédicats utiles permettent de classifier une adresse sans aucun appel réseau : isLoopbackAddress(), isSiteLocalAddress() (plages privées comme 10.x / 192.168.x), isMulticastAddress(), isAnyLocalAddress() (le caractère générique 0.0.0.0), et isReachable(timeout) (une sonde de type ping — la seule méthode ici qui touche vraiment le réseau).

Exemple concret : créer et classifier des adresses

Ce programme crée des adresses de plusieurs façons — loopback, littéral IPv4, octets bruts, littéral IPv6 — et inspecte chacune avec les prédicats de classification. Il utilise délibérément des littéraux et le loopback pour fonctionner hors ligne ; le seul appel dépendant du DNS (getLocalHost) est protégé.

java— editable, runs on the server

import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressDemo {
  public static void main(String[] args) throws Exception {
    // Loopback: always available, no DNS
    InetAddress loopback = InetAddress.getLoopbackAddress();
    System.out.println("loopback name : " + loopback.getHostName());
    System.out.println("loopback addr : " + loopback.getHostAddress());
    System.out.println("is loopback?  : " + loopback.isLoopbackAddress());

// Parse an IPv4 literal (numeric => no DNS query)
    InetAddress ipv4 = InetAddress.getByName("93.184.216.34");
    System.out.println("\nipv4 address  : " + ipv4.getHostAddress());
    System.out.println("raw byte count: " + ipv4.getAddress().length);
    System.out.println("is multicast? : " + ipv4.isMulticastAddress());

// Build an address from raw bytes (a private 10.x address)
    InetAddress fromBytes = InetAddress.getByAddress(new byte[]{10, 0, 0, 1});
    System.out.println("\nfrom bytes    : " + fromBytes.getHostAddress());
    System.out.println("is site-local?: " + fromBytes.isSiteLocalAddress());

// IPv6 loopback literal
    InetAddress ipv6 = InetAddress.getByName("::1");
    System.out.println("\nipv6 address  : " + ipv6.getHostAddress());
    System.out.println("raw byte count: " + ipv6.getAddress().length);
    System.out.println("is Inet6?     : " + (ipv6 instanceof Inet6Address));

// The local host name/address may require resolution; guard it
    try {
      InetAddress local = InetAddress.getLocalHost();
      System.out.println("\nlocal host    : " + local);
    } catch (UnknownHostException e) {
      System.out.println("\nlocal host unresolved: " + e.getMessage());
    }
  }
}

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

Les adresses ont été créées sans constructeur — chaque instance provient d'une méthode fabrique : getLoopbackAddress, getByName, getByAddress. Cette conception permet à la JVM de mettre les résolutions en cache et de retourner la bonne sous-classe (Inet4Address vs Inet6Address) automatiquement.
getByName("93.184.216.34") et getByName("::1") n'ont effectué aucune requête DNS car les arguments étaient des littéraux numériques — la méthode les a simplement parsés. Le même appel avec un nom d'hôte aurait sollicité le DNS, le chemin lent et susceptible d'échouer hors ligne ; savoir quelles entrées déclenchent une résolution est important pour les performances.
Le nombre d'octets bruts distinguait les familles : l'adresse IPv4 signalait 4 octets, l'adresse IPv6 en signalait 16, et instanceof Inet6Address confirmait le type concret. Le code qui traite les adresses de manière générique passe par le supertype InetAddress et a rarement besoin de distinguer les familles.
Les prédicats de classification ont répondu à des questions structurelles sans réseau : l'adresse loopback a renvoyé true pour isLoopbackAddress(), et le 10.0.0.1 construit à partir d'octets a renvoyé true pour isSiteLocalAddress() (une plage privée). Ces vérifications sont de l'arithmétique pure sur les octets de l'adresse.
getLocalHost() a été enveloppé dans un try/catch car il peut échouer avec UnknownHostException lorsque le nom de la machine elle-même n'est pas résolvable. La résolution d'adresse est fondamentalement une opération réseau/DNS susceptible d'échouer, donc un code robuste anticipe toujours le cas non résolu — la même prudence que chaque chapitre de cette partie a appliquée au réseau lui-même.

Pratique

Un service sensible à la latence appelle 'InetAddress.getByName(host)' dans une boucle serrée, où 'host' est parfois un nom de domaine et parfois un littéral IP numérique. Le profilage montre des blocages occasionnels de plusieurs centaines de millisecondes. Quelle est la meilleure explication ?

Quand 'host' est un nom de domaine, 'getByName' effectue une résolution DNS (lente, dépendante du réseau) ; les littéraux numériques sont simplement parsés, donc mettre en cache les adresses résolues ou passer des littéraux IP évite les blocages'getByName' bloque toujours pendant un 200ms fixe par conception, quelle que soit l'entrée, pour limiter le débit réseauLes blocages viennent de la construction des objets 'InetAddress', qui sont extrêmement coûteux à allouer ; réutilisez une seule instanceLes littéraux IP numériques déclenchent une résolution DNS inverse tandis que les noms de domaine ne le font pas, donc passer des noms est en réalité plus rapide