Java InetAddress-Klasse | W3Docs Learn Java

Jede Verbindung in diesem Teil benötigte eine Adresse — einen Host und einen Port. java.net.InetAddress ist die Klasse, die den Host-Teil repräsentiert: eine IP-Adresse, optional gepaart mit einem Hostnamen. Sie ist auch das Tor zu DNS (dem Domain Name System), das einen Namen wie example.com in die numerische Adresse umwandelt, an die das Netzwerk tatsächlich weiterleitet. Dieses letzte Networking-Kapitel behandelt das Erstellen, Auflösen und Untersuchen von Adressen. Die InetAddress-Instanzen, die Sie hier erstellen, sind genau die, die Sie an einen Socket, einen ServerSocket oder einen DatagramSocket übergeben, um tatsächlich eine Verbindung herzustellen.

Kein öffentlicher Konstruktor — Factory-Methoden verwenden

Sie schreiben nie new InetAddress(...). Stattdessen:

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

Wesentlicher Unterschied: getByName mit einem Hostnamen führt eine DNS-Abfrage durch (die langsam sein oder offline eine UnknownHostException auslösen kann); mit einem numerischen Literal wird der Wert nur geparst, ohne Netzwerkzugriff. getByAddress erstellt eine Adresse aus rohen Bytes ohne jede Auflösung.

Wann greife ich darauf zurück? Immer dann, wenn Sie einen Namen vor dem Verbinden auflösen müssen, eine Adresse validieren oder klassifizieren möchten (Loopback, privat, Multicast) oder eine gecachte Adresse behalten wollen, um wiederholte DNS-Abfragen in einem Hot Path zu vermeiden. Eine übergeordnete Hilfsklasse wie die URL-Klasse löst Hosts im Hintergrund für Sie auf; InetAddress ist die Schicht, auf die Sie zurückgreifen, wenn Sie die Adresse selbst benötigen.

IPv4 und IPv6

InetAddress ist der gemeinsame Supertyp; konkrete Instanzen sind Inet4Address (32-Bit, 93.184.216.34) oder Inet6Address (128-Bit, ::1). getAddress() gibt die rohen Bytes zurück (4 oder 16), und getHostAddress() gibt die kanonische Textform zurück. Code sollte beide Adressfamilien einheitlich über den Typ InetAddress behandeln.

Eine Adresse untersuchen

Nützliche Prädikate klassifizieren eine Adresse ohne Netzwerkaufruf: isLoopbackAddress(), isSiteLocalAddress() (private Bereiche wie 10.x / 192.168.x), isMulticastAddress(), isAnyLocalAddress() (der Platzhalter 0.0.0.0) und isReachable(timeout) (eine echte Ping-ähnliche Prüfung — die einzige Methode hier, die tatsächlich das Netzwerk kontaktiert).

Ein praktisches Beispiel: Adressen erstellen und klassifizieren

Dieses Programm erstellt Adressen auf verschiedene Arten — Loopback, ein IPv4-Literal, rohe Bytes, ein IPv6-Literal — und untersucht jede mit den Klassifikationsprädikaten. Es verwendet absichtlich Literale und Loopback, damit es offline läuft; der einzige DNS-abhängige Aufruf (getLocalHost) ist geschützt.

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

Was man aus der Ausführung mitnehmen kann:

Adressen wurden ohne Konstruktor erstellt — jede Instanz kam von einer Factory: getLoopbackAddress, getByName, getByAddress. Dieses Design ermöglicht es der JVM, Lookups zu cachen und die richtige Unterklasse (Inet4Address vs. Inet6Address) für Sie zurückzugeben.
getByName("93.184.216.34") und getByName("::1") haben keine DNS-Abfrage durchgeführt, weil die Argumente numerische Literale waren — die Methode hat sie nur geparst. Derselbe Aufruf mit einem Hostnamen hätte DNS kontaktiert, was der langsame, offline-anfällige Pfad ist; zu wissen, welche Eingaben eine Abfrage auslösen, ist für die Performance wichtig.
Die Anzahl der rohen Bytes unterschied die Adressfamilien: die IPv4-Adresse meldete 4 Bytes, die IPv6-Adresse 16, und instanceof Inet6Address bestätigte den konkreten Typ. Code, der Adressen generisch behandelt, arbeitet über den Supertyp InetAddress und muss selten nach der Familie verzweigen.
Die Klassifikationsprädikate beantworteten strukturelle Fragen ohne Netzwerkzugriff: die Loopback-Adresse lieferte true für isLoopbackAddress(), und die aus Bytes erstellte 10.0.0.1 lieferte true für isSiteLocalAddress() (ein privater Bereich). Diese Prüfungen sind reine Arithmetik auf den Adress-Bytes.
getLocalHost() war in einem try/catch eingebettet, weil es mit UnknownHostException fehlschlagen kann, wenn der eigene Name des Rechners nicht auflösbar ist. Adressauflösung ist im Wesentlichen eine Netzwerk-/DNS-Operation, die fehlschlagen kann, daher antizipiert robuster Code stets den unaufgelösten Fall — dieselbe Vorsicht, die jedes Kapitel in diesem Teil auf das Netzwerk selbst anwendete.

Übungen

Übung

Ein latenzempfindlicher Dienst ruft 'InetAddress.getByName(host)' in einer engen Schleife auf, wobei 'host' manchmal ein Domainname und manchmal ein numerisches IP-Literal ist. Das Profiling zeigt gelegentliche Verzögerungen von mehreren hundert Millisekunden. Was ist die beste Erklärung?

Wenn 'host' ein Domainname ist, führt 'getByName' einen DNS-Lookup durch (langsam, netzwerkabhängig); numerische Literale werden nur geparst, daher vermeidet das Cachen aufgelöster Adressen oder die Übergabe von IP-Literalen die Verzögerungen'getByName' blockiert immer für eine feste Zeit von 200ms, unabhängig von der Eingabe, um das Netzwerk zu drosselnDie Verzögerungen entstehen durch das Erzeugen von 'InetAddress'-Objekten, die sehr teuer in der Allokation sind; eine einzelne Instanz sollte wiederverwendet werdenNumerische IP-Literale lösen einen Reverse-DNS-Lookup aus, während Domainnamen dies nicht tun, daher ist die Übergabe von Namen tatsächlich schneller