Classe Java InetAddress | W3Docs Learn Java

Ogni connessione in questa parte richiedeva un indirizzo — un host e una porta. java.net.InetAddress è la classe che rappresenta la parte host: un indirizzo IP, facoltativamente abbinato a un hostname. È anche il punto di accesso al DNS (Domain Name System), che converte un nome come example.com nell'indirizzo numerico su cui la rete instrada effettivamente. Quest'ultimo capitolo di Networking tratta la creazione, la risoluzione e l'ispezione degli indirizzi. Le stesse istanze di InetAddress che costruisci qui sono quelle che passi a un Socket, un ServerSocket o un DatagramSocket per effettuare la connessione.

Nessun costruttore pubblico — usa i factory method

Non si scrive mai new InetAddress(...). Invece:

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

Distinzione fondamentale: getByName con un hostname esegue una query DNS (che può essere lenta o lanciare UnknownHostException offline); con un letterale numerico si limita ad analizzarlo, senza rete. getByAddress costruisce un indirizzo dai byte grezzi senza alcuna ricerca.

Quando lo uso? Ogni volta che devi risolvere un nome prima di connetterti, validare o classificare un indirizzo (loopback, privato, multicast), oppure conservare un indirizzo in cache per saltare lookup DNS ripetuti in un percorso critico. Un helper di livello superiore come la classe URL risolve gli host internamente; InetAddress è il livello a cui scendi quando hai bisogno dell'indirizzo stesso.

IPv4 e IPv6

InetAddress è il supertipo comune; le istanze concrete sono Inet4Address (32 bit, 93.184.216.34) o Inet6Address (128 bit, ::1). getAddress() restituisce i byte grezzi (4 o 16), e getHostAddress() restituisce la forma testuale canonica. Il codice dovrebbe trattare entrambe le famiglie in modo uniforme tramite il tipo InetAddress.

Ispezione di un indirizzo

Utili predicati classificano un indirizzo senza alcuna chiamata di rete: isLoopbackAddress(), isSiteLocalAddress() (intervalli privati come 10.x / 192.168.x), isMulticastAddress(), isAnyLocalAddress() (il carattere jolly 0.0.0.0), e isReachable(timeout) (una vera sonda di tipo ping — l'unico metodo qui che colpisce davvero la rete).

Un esempio completo: creare e classificare indirizzi

Questo programma crea indirizzi in diversi modi — loopback, un letterale IPv4, byte grezzi, un letterale IPv6 — e ispeziona ciascuno con i predicati di classificazione. Usa deliberatamente letterali e loopback così funziona offline; l'unica chiamata dipendente dal DNS (getLocalHost) è protetta.

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

Cosa ricavare dall'esecuzione:

Gli indirizzi sono stati creati senza un costruttore — ogni istanza proviene da un factory: getLoopbackAddress, getByName, getByAddress. Questo design permette alla JVM di mettere in cache i lookup e restituirti la sottoclasse corretta (Inet4Address vs Inet6Address).
getByName("93.184.216.34") e getByName("::1") non hanno eseguito query DNS perché gli argomenti erano letterali numerici — il metodo li ha solo analizzati. La stessa chiamata con un hostname avrebbe colpito il DNS, che è il percorso lento e soggetto a errori offline; sapere quali input attivano un lookup è importante per le prestazioni.
Il numero di byte grezzi ha distinto le famiglie: l'indirizzo IPv4 ha riportato 4 byte, quello IPv6 16, e instanceof Inet6Address ha confermato il tipo concreto. Il codice che gestisce gli indirizzi in modo generico opera tramite il supertipo InetAddress e raramente ha bisogno di ramificarsi sulla famiglia.
I predicati di classificazione hanno risposto a domande strutturali senza rete: l'indirizzo loopback ha testato true per isLoopbackAddress(), e il 10.0.0.1 costruito dai byte ha testato true per isSiteLocalAddress() (un intervallo privato). Questi controlli sono pura aritmetica sui byte dell'indirizzo.
getLocalHost() era avvolto in un try/catch perché può fallire con UnknownHostException quando il nome della propria macchina non è risolvibile. La risoluzione degli indirizzi è fondamentalmente un'operazione di rete/DNS che può fallire, quindi il codice robusto anticipa sempre il caso non risolto — la stessa cautela che ogni capitolo in questa parte ha applicato alla rete stessa.

Esercitazione

Pratica

Un servizio sensibile alla latenza chiama 'InetAddress.getByName(host)' in un ciclo stretto, dove 'host' è a volte un nome di dominio e a volte un letterale IP numerico. Il profiling mostra stalli occasionali di alcune centinaia di millisecondi. Qual è la spiegazione migliore?

Quando 'host' è un nome di dominio, 'getByName' esegue una query DNS (lenta, dipendente dalla rete); i letterali numerici vengono solo analizzati, quindi la cache degli indirizzi risolti o l'uso di letterali IP evita gli stalli'getByName' blocca sempre per un fisso di 200ms per design, indipendentemente dall'input, per limitare la frequenza della reteGli stalli derivano dalla costruzione di oggetti 'InetAddress', che sono estremamente costosi da allocare; riutilizza una singola istanzaI letterali IP numerici attivano un lookup DNS inverso mentre i nomi di dominio no, quindi passare i nomi è in realtà più veloce