Java实现域名解析的示例详解(附带源码)

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
 
/**
 * DNSUtil 工具类
 * 提供域名编码和字节转换等辅助方法
 */
class DNSUtil {
    /**
     * 将域名转换为 DNS 协议格式的字节数组
     * 例如，将 "www.example.com" 转换为 [3, 'w','w','w', 7, 'e','x','a','m','p','l','e', 3, 'c','o','m', 0]
     *
     * @param domain 待转换的域名字符串
     * @return 转换后的字节数组
     */
    public static byte[] encodeDomainName(String domain) {
        String[] labels = domain.split("\\.");
        ByteBuffer buffer = ByteBuffer.allocate(domain.length() + 2);
        for (String label : labels) {
            buffer.put((byte) label.length());
            buffer.put(label.getBytes());
        }
        // 结尾为0
        buffer.put((byte) 0);
        buffer.flip();
        byte[] result = new byte[buffer.limit()];
        buffer.get(result);
        return result;
    }
 
    /**
     * 将一个 16 位整数转换为两个字节（大端序，即网络字节序）
     *
     * @param value 要转换的整数
     * @return 转换后的 2 字节数组
     */
    public static byte[] shortToBytes(int value) {
        return new byte[] {
            (byte) ((value >> 8) & 0xFF),
            (byte) (value & 0xFF)
        };
    }
 
    /**
     * 从字节数组中读取一个 16 位整数（大端序）
     *
     * @param data   字节数组
     * @param offset 读取起始位置
     * @return 读取到的整数
     */
    public static int bytesToShort(byte[] data, int offset) {
        return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
    }
}
 
/**
 * DNSQuery 类
 * 该类实现了 DNS 查询报文的构造、UDP 发送与响应报文解析
 */
public class DNSQuery {
    // DNS 服务器 IP，默认使用 Google 的公共 DNS
    private static final String DNS_SERVER = "8.8.8.8";
    // DNS 服务器端口（标准 DNS 使用 53 端口）
    private static final int DNS_PORT = 53;
    // 查询超时时间（毫秒）
    private static final int TIMEOUT = 5000;
 
    /**
     * 构造 DNS 查询报文
     *
     * @param domain 待解析的域名
     * @return 构造好的 DNS 查询报文字节数组
     */
    private static byte[] buildQuery(String domain) {
        // DNS 报文头固定 12 字节
        ByteBuffer buffer = ByteBuffer.allocate(512); // DNS 报文最大512字节（不考虑扩展）
        
        // 1. 构造 Header
        // 随机生成一个 16 位标识符（ID）
        int transactionId = (int) (Math.random() * 0xFFFF);
        buffer.putShort((short) transactionId);
        // 设置标志：0x0100 表示标准查询，递归查询
        buffer.putShort((short) 0x0100);
        // 问题数 QDCOUNT 设置为 1
        buffer.putShort((short) 1);
        // 回答数 ANCOUNT 设置为 0
        buffer.putShort((short) 0);
        // 授权记录数 NSCOUNT 设置为 0
        buffer.putShort((short) 0);
        // 附加记录数 ARCOUNT 设置为 0
        buffer.putShort((short) 0);
 
        // 2. 构造 Question 部分
        // 将域名编码为 DNS 协议格式
        byte[] domainBytes = DNSUtil.encodeDomainName(domain);
        buffer.put(domainBytes);
        // 查询类型 QTYPE：A 记录为 1
        buffer.putShort((short) 1);
        // 查询类 QCLASS：IN（互联网）为 1
        buffer.putShort((short) 1);
 
        // 返回实际使用的字节数组
        byte[] queryData = new byte[buffer.position()];
        buffer.flip();
        buffer.get(queryData);
        return queryData;
    }
 
    /**
     * 解析 DNS 响应报文，提取 A 记录对应的 IP 地址列表
     *
     * @param response DNS 响应报文字节数组
     * @return 解析得到的 IP 地址列表
     */
    private static List<String> parseResponse(byte[] response) {
        List<String> ipList = new ArrayList<>();
        // 使用 ByteBuffer 方便读取字节数据
        ByteBuffer buffer = ByteBuffer.wrap(response);
 
        // 解析 Header 部分（12 字节）
        int transactionId = buffer.getShort() & 0xFFFF;
        int flags = buffer.getShort() & 0xFFFF;
        int qdCount = buffer.getShort() & 0xFFFF;
        int anCount = buffer.getShort() & 0xFFFF;
        int nsCount = buffer.getShort() & 0xFFFF;
        int arCount = buffer.getShort() & 0xFFFF;
 
        // 跳过 Question 部分
        for (int i = 0; i < qdCount; i++) {
            // 跳过域名：直到遇到 0 字节
            while (true) {
                byte len = buffer.get();
                if (len == 0) break;
                buffer.position(buffer.position() + (len & 0xFF));
            }
            // 跳过 QTYPE 和 QCLASS 各 2 字节
            buffer.getShort();
            buffer.getShort();
        }
 
        // 解析 Answer 部分
        for (int i = 0; i < anCount; i++) {
            // 回答部分中的名称字段（可能为指针形式，这里直接跳过2字节）
            short nameField = buffer.getShort();
            // 读取 TYPE 和 CLASS 字段
            int type = buffer.getShort() & 0xFFFF;
            int clazz = buffer.getShort() & 0xFFFF;
            // 读取 TTL（4字节）
            int ttl = buffer.getInt();
            // 读取 RDLENGTH（2字节）
            int rdLength = buffer.getShort() & 0xFFFF;
 
            // 如果 TYPE 为 1（A 记录），解析 4 字节 IPv4 地址
            if (type == 1 && rdLength == 4) {
                byte[] ipBytes = new byte[4];
                buffer.get(ipBytes);
                String ip = (ipBytes[0] & 0xFF) + "." +
                            (ipBytes[1] & 0xFF) + "." +
                            (ipBytes[2] & 0xFF) + "." +
                            (ipBytes[3] & 0xFF);
                ipList.add(ip);
            } else {
                // 跳过该资源数据
                buffer.position(buffer.position() + rdLength);
            }
        }
        return ipList;
    }
 
    /**
     * 发送 DNS 查询请求并解析响应
     *
     * @param domain 待解析的域名
     * @return 解析得到的 IP 地址列表
     */
    public static List<String> resolve(String domain) {
        List<String> ipList = new ArrayList<>();
        try (DatagramSocket socket = new DatagramSocket()) {
            socket.setSoTimeout(TIMEOUT);
            // 构造 DNS 查询报文
            byte[] queryData = buildQuery(domain);
            InetAddress dnsServerAddress = InetAddress.getByName(DNS_SERVER);
            DatagramPacket requestPacket = new DatagramPacket(queryData, queryData.length, dnsServerAddress, DNS_PORT);
            // 发送请求
            socket.send(requestPacket);
 
            // 接收响应
            byte[] responseData = new byte[512];
            DatagramPacket responsePacket = new DatagramPacket(responseData, responseData.length);
            socket.receive(responsePacket);
 
            // 解析响应报文
            ipList = parseResponse(responseData);
        } catch (Exception e) {
            System.err.println("解析域名时发生异常：" + e.getMessage());
        }
        return ipList;
    }
 
    /**
     * 主函数，提供命令行入口
     * 使用方法：java DNSQuery [域名]
     *
     * @param args 命令行参数，包含待解析域名
     */
    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("请输入要解析的域名，例如：java DNSQuery www.example.com");
            return;
        }
        String domain = args[0];
        System.out.println("正在解析域名：" + domain);
        List<String> ips = resolve(domain);
        if (ips.isEmpty()) {
            System.out.println("未解析到任何 IP 地址。");
        } else {
            System.out.println("解析结果：");
            for (String ip : ips) {
                System.out.println("IP 地址：" + ip);
            }
        }
    }
}

javac DNSQuery.java
java DNSQuery www.example.com