Clase Java InetAddress | W3Docs Learn Java

Toda conexión en esta parte necesitó una dirección — un host y un puerto. java.net.InetAddress es la clase que representa la parte del host: una dirección IP, opcionalmente emparejada con un nombre de host. También es la puerta de entrada al DNS (el Sistema de Nombres de Dominio), que convierte un nombre como example.com en la dirección numérica a la que la red realmente enruta. Este último capítulo de Networking cubre la creación, resolución e inspección de direcciones. Las mismas instancias de InetAddress que construyes aquí son las que pasas a un Socket, un ServerSocket o un DatagramSocket para conectarte realmente.

Sin constructor público — usa métodos de fábrica

Nunca escribirás new InetAddress(...). En su lugar:

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

Distinción clave: getByName con un nombre de host realiza una consulta DNS (que puede ser lenta o lanzar UnknownHostException sin conexión); con un literal numérico solo lo analiza, sin red. getByAddress construye una dirección a partir de bytes sin ninguna búsqueda.

¿Cuándo usaría esto? Siempre que necesites resolver un nombre antes de conectarte, validar o clasificar una dirección (loopback, privada, multicast), o conservar una dirección en caché para evitar búsquedas DNS repetidas en un camino crítico. Un helper de más alto nivel como la clase URL resuelve los hosts por ti en segundo plano; InetAddress es la capa a la que desciendes cuando necesitas la dirección en sí.

IPv4 e IPv6

InetAddress es el supertipo común; las instancias concretas son Inet4Address (32 bits, 93.184.216.34) o Inet6Address (128 bits, ::1). getAddress() devuelve los bytes sin formato (4 o 16), y getHostAddress() devuelve la forma textual canónica. El código debe tratar ambas familias de forma uniforme a través del tipo InetAddress.

Inspeccionando una dirección

Predicados útiles clasifican una dirección sin ninguna llamada de red: isLoopbackAddress(), isSiteLocalAddress() (rangos privados como 10.x / 192.168.x), isMulticastAddress(), isAnyLocalAddress() (el comodín 0.0.0.0), y isReachable(timeout) (una sonda real tipo ping — el único método aquí que sí toca la red).

Un ejemplo práctico: crear y clasificar direcciones

Este programa crea direcciones de varias formas — loopback, un literal IPv4, bytes sin formato, un literal IPv6 — e inspecciona cada una con los predicados de clasificación. Deliberadamente usa literales y loopback para que funcione sin conexión; la única llamada dependiente de DNS (getLocalHost) está protegida.

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

Lo que se puede extraer de la ejecución:

Las direcciones se crearon sin un constructor — cada instancia provino de una fábrica: getLoopbackAddress, getByName, getByAddress. Ese diseño permite a la JVM almacenar en caché las búsquedas y devolver la subclase correcta (Inet4Address vs Inet6Address) por ti.
getByName("93.184.216.34") y getByName("::1") no realizaron ninguna consulta DNS porque los argumentos eran literales numéricos — el método simplemente los analizó. La misma llamada con un nombre de host habría tocado el DNS, que es el camino lento y con fallos sin conexión; saber qué entradas desencadenan una búsqueda importa para el rendimiento.
El número de bytes sin formato distinguió las familias: la dirección IPv4 reportó 4 bytes, la dirección IPv6 16, y instanceof Inet6Address confirmó el tipo concreto. El código que maneja direcciones de forma genérica trabaja a través del supertipo InetAddress y raramente necesita ramificar según la familia.
Los predicados de clasificación respondieron preguntas estructurales sin red: la dirección loopback dio true para isLoopbackAddress(), y el 10.0.0.1 construido desde bytes dio true para isSiteLocalAddress() (un rango privado). Estas comprobaciones son aritmética pura sobre los bytes de la dirección.
getLocalHost() fue envuelto en un try/catch porque puede fallar con UnknownHostException cuando el propio nombre de la máquina no es resoluble. La resolución de direcciones es fundamentalmente una operación de red/DNS que puede fallar, por lo que el código robusto siempre anticipa el caso no resuelto — la misma precaución que cada capítulo de esta parte aplicó a la red en sí.

Práctica

Un servicio sensible a la latencia llama a 'InetAddress.getByName(host)' en un bucle cerrado, donde 'host' es a veces un nombre de dominio y a veces un literal IP numérico. El perfilado muestra estancamientos ocasionales de varios cientos de milisegundos. ¿Cuál es la mejor explicación?

Cuando 'host' es un nombre de dominio, 'getByName' realiza una búsqueda DNS (lenta, dependiente de la red); los literales numéricos solo se analizan, por lo que almacenar en caché las direcciones resueltas o pasar literales IP evita los estancamientos'getByName' siempre bloquea durante un 200ms fijo por diseño, independientemente de la entrada, para limitar la velocidad de la redLos estancamientos provienen de construir objetos 'InetAddress', que son extremadamente costosos de asignar; reutiliza una sola instanciaLos literales IP numéricos desencadenan una búsqueda DNS inversa mientras que los nombres de dominio no, por lo que pasar nombres es realmente más rápido