Classe Java InetAddress | W3Docs Learn Java

Cada conexão nesta parte precisou de um endereço — um host e uma porta. java.net.InetAddress é a classe que representa a parte do host: um endereço IP, opcionalmente combinado com um nome de host. É também a porta de entrada para o DNS (o Sistema de Nomes de Domínio), convertendo um nome como example.com no endereço numérico para o qual a rede realmente roteia. Este capítulo final de Networking aborda a criação, resolução e inspeção de endereços. As mesmas instâncias de InetAddress que você constrói aqui são as que você passa para um Socket, um ServerSocket, ou um DatagramSocket para realmente conectar.

Sem construtor público — use métodos de fábrica

Você nunca escreve new InetAddress(...). Em vez disso:

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

Distinção fundamental: getByName com um nome de host realiza uma consulta DNS (que pode ser lenta ou lançar UnknownHostException quando offline); com um literal numérico apenas analisa, sem rede. getByAddress constrói um endereço a partir de bytes brutos sem nenhuma consulta.

Quando eu usaria isso? Sempre que você precisar resolver um nome antes de conectar, validar ou classificar um endereço (loopback, privado, multicast), ou manter um endereço em cache para evitar consultas DNS repetidas em um caminho crítico. Um auxiliar de nível mais alto como a classe URL resolve hosts para você nos bastidores; InetAddress é a camada para a qual você desce quando precisa do endereço em si.

IPv4 e IPv6

InetAddress é o supertipo comum; as instâncias concretas são Inet4Address (32 bits, 93.184.216.34) ou Inet6Address (128 bits, ::1). getAddress() retorna os bytes brutos (4 ou 16), e getHostAddress() retorna a forma textual canônica. O código deve tratar ambas as famílias de forma uniforme através do tipo InetAddress.

Inspecionando um endereço

Predicados úteis classificam um endereço sem nenhuma chamada de rede: isLoopbackAddress(), isSiteLocalAddress() (intervalos privados como 10.x / 192.168.x), isMulticastAddress(), isAnyLocalAddress() (o curinga 0.0.0.0), e isReachable(timeout) (uma sonda no estilo ping real — o único método aqui que realmente acessa a rede).

Um exemplo prático: construindo e classificando endereços

Este programa cria endereços de várias formas — loopback, um literal IPv4, bytes brutos, um literal IPv6 — e inspeciona cada um com os predicados de classificação. Ele usa deliberadamente literais e loopback para funcionar offline; a única chamada dependente de DNS (getLocalHost) é 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());
    }
  }
}

O que observar na execução:

Os endereços foram criados sem um construtor — cada instância veio de uma fábrica: getLoopbackAddress, getByName, getByAddress. Esse design permite que a JVM armazene em cache as consultas e retorne a subclasse correta (Inet4Address vs Inet6Address) para você.
getByName("93.184.216.34") e getByName("::1") não realizaram nenhuma consulta DNS porque os argumentos eram literais numéricos — o método apenas os analisou. A mesma chamada com um nome de host teria acessado o DNS, que é o caminho lento e que falha quando offline; saber quais entradas acionam uma consulta é importante para o desempenho.
O número de bytes brutos distinguiu as famílias: o endereço IPv4 reportou 4 bytes, o endereço IPv6 reportou 16, e instanceof Inet6Address confirmou o tipo concreto. Código que manipula endereços de forma genérica trabalha através do supertipo InetAddress e raramente precisa ramificar com base na família.
Os predicados de classificação responderam a perguntas estruturais sem rede: o endereço loopback retornou true para isLoopbackAddress(), e o 10.0.0.1 construído a partir de bytes retornou true para isSiteLocalAddress() (um intervalo privado). Essas verificações são pura aritmética sobre os bytes do endereço.
getLocalHost() foi encapsulado em um try/catch porque pode falhar com UnknownHostException quando o próprio nome da máquina não é resolvível. A resolução de endereços é fundamentalmente uma operação de rede/DNS que pode falhar, portanto um código robusto sempre antecipa o caso não resolvido — o mesmo cuidado que cada capítulo desta parte aplicou à própria rede.

Prática

Um serviço sensível à latência chama 'InetAddress.getByName(host)' em um loop intenso, onde 'host' é às vezes um nome de domínio e às vezes um literal IP numérico. O profiling mostra travamentos ocasionais de vários centenas de milissegundos. Qual é a melhor explicação?

Quando 'host' é um nome de domínio, 'getByName' realiza uma consulta DNS (lenta, dependente de rede); literais numéricos são apenas analisados, portanto armazenar endereços resolvidos em cache ou passar literais IP evita os travamentos'getByName' sempre bloqueia por 200ms fixos por design, independentemente da entrada, para limitar a taxa da redeOs travamentos vêm da construção de objetos 'InetAddress', que são extremamente caros de alocar; reutilize uma única instânciaLiterais IP numéricos acionam uma consulta DNS reversa enquanto os nomes de domínio não, portanto passar nomes é na verdade mais rápido