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

目录

• 1. 引言
• 2. DNS 基本知识与原理
• 2.1 什么是 DNS
• 2.2 DNS 协议概述
• 2.3 DNS 查询过程 
• 3. 项目需求与目标
• 3.1 项目目标
• 3.2 需求描述
• 3.3 扩展目标
• 4. 项目整体架构设计
• 4.1 模块划分
• 4.2 交互流程说明
• 5. DNS 协议详细解析
• 5.1 DNS 报文头（Header）
• 5.2 DNS 问题部分（Question）
• 5.3 DNS 回答部分（Answer）
• 6. Java 实现 DNS 客户端的详细设计
• 6.1 设计模块划分
• 7. 实现代码及详细注释
• 8. 代码解读
• 8.1 DNSUtil 类的作用
• 8.2 DNSQuery 类核心方法
• 8.3 主函数 main 方法
• 9. 测试与运行结果
• 9.1 测试方法
• 9.2 运行结果分析
• 10. 项目总结与心得体会
• 10.1 项目总结
• 10.2 心得体会
• 11. 扩展讨论与未来展望
• 12. 附录
• 13. 总结

1. 引言

在互联网中，域名作为一种便于人类记忆和使用的标识符，背后都对应着唯一的 IP 地址。域名解析（DNS，Domain Name System）则是将域名转换成 IP 地址的关键技术。无论是访问网站、发送邮件还是进行各种网络通信，都离不开 DNS 的支持。虽然 Java 内置了通过 InetAddress 类进行域名解析的简单方式，但为了深入理解 DNS 协议的底层原理以及网络编程的实现方式，本文将从零开始构造一个 DNS 客户端，利用 Java 手动构造 DNS 查询报文，发送 UDP 数据包给 DNS 服务器，并解析返回的响应数据，从而实现对域名解析的完整流程。

本项目不仅有助于大家理解 DNS 协议的结构与工作原理，同时也是 Java 网络编程、字节处理和数据协议解析的一次实战演练。本文将从理论到实践、从代码到测试，全方位地讲解如何利用 Java 实现一个简单的域名解析器。

2. DNS 基本知识与原理

2.1 什么是 DNS

域名系统（DNS）是互联网的一项基础服务，它将便于记忆的域名（如 www.example.com）转换为计算机能够识别的 IP 地址（如 93.184.216.34）。DNS 采用分布式数据库方式组织数据，通过层次化结构（根域名服务器、顶级域名服务器、权威域名服务器等）进行管理和查询。

2.2 DNS 协议概述

DNS 协议基于 UDP（也可使用 TCP，主要在数据量较大或传输可靠性要求高的情况下使用），采用固定格式的报文进行通信。DNS 报文主要由以下几部分构成：

• Header（报文头）： 固定 12 字节，包含标识符、标志位、问题数、回答数、授权记录数和附加记录数等信息。
• Question（问题部分）： 包含查询的域名、查询类型（如 A 记录、MX 记录等）和查询类（一般为 IN，即互联网）。
• Answer（回答部分）： 如果查询成功，回答部分将包含解析得到的资源记录，如 IP 地址、域名别名等。
• Authority（授权部分）： 指出权威的域名服务器。
• Additional（附加部分）： 提供额外的辅助信息。

在本项目中，我们主要关注 A 记录解析，即将域名解析为 IPv4 地址。

2.3 DNS 查询过程 

DNS 查询的基本过程如下：

• 客户端构造 DNS 查询报文，并向指定的 DNS 服务器（如 Google 的 8.8.8.8）发送 UDP 数据包。
• DNS 服务器接收到查询后，根据域名查找相应的资源记录，将查询结果打包到响应报文中返回给客户端。
• 客户端收到响应报文后，解析 Header、Question、Answer 等部分，从中提取出解析结果（例如 IP 地址）。

通过构造和解析 DNS 报文，客户端便能实现对域名的解析。

3. 项目需求与目标

3.1 项目目标

实现 DNS 查询： 利用 Java 手动构造 DNS 查询报文，向 DNS 服务器发送请求，并解析返回结果，获取目标域名的 IP 地址。

底层协议解析： 深入理解 DNS 报文的各个字段及其含义，实现 Header、Question、Answer 部分的解析。

网络编程实战： 使用 UDP 协议进行数据包传输，掌握 DatagramSocket 的使用方法。

代码易读性与扩展性： 代码整合在一起，并附有详细注释，方便读者理解与扩展。

3.2 需求描述

输入： 用户输入待解析的域名（如 "www.example.com"）。

处理：

• 构造 DNS 查询报文，包括报文头和查询问题部分。
• 通过 UDP 将报文发送到 DNS 服务器（例如 8.8.8.8）。
• 接收并解析 DNS 服务器返回的响应数据，提取 IP 地址信息。

输出： 显示解析后的 IP 地址，若存在多个 IP 地址，则全部输出。

3.3 扩展目标

多种记录类型： 本项目主要解析 A 记录，后续可扩展解析 AAAA、MX、CNAME 等其他记录。

错误处理与超时机制： 对于 DNS 服务器无响应、数据包丢失等情况，设计合理的超时与重传机制。

图形化界面： 后续可考虑结合 Swing 或 JavaFX 实现简单的图形化用户界面，便于使用。

4. 项目整体架构设计

为实现域名解析，我们将项目划分为以下几个模块：

4.1 模块划分

DNS 查询报文构造模块：

• 负责构造 DNS 报文的 Header 和 Question 部分。
• 包含域名编码（将普通域名转换为 DNS 协议格式，如 3www7example3com0）。

UDP 通信模块：

• 使用 Java 的 DatagramSocket 发送构造好的查询报文，并等待接收响应报文。
• 实现超时机制，确保在 DNS 服务器无响应时能够退出。

DNS 响应报文解析模块：

• 对收到的响应报文进行解析，读取 Header、Question 和 Answer 部分。
• 提取并展示答案记录中的 IP 地址。

用户交互模块：

• 提供命令行输入，用户输入域名后启动 DNS 查询过程。
• 输出查询结果及相关日志信息，便于调试和理解整个流程。

4.2 交互流程说明

输入阶python段： 用户通过命令行或配置文件输入需要解析的域名。

查询阶段：

• 构造 DNS 查询报文，编码域名，并填充查询类型（A 记录）和查询类（IN）。
• 通过 UDP 将报文发送到指定 DNS 服务器。

响应阶段：

• 接收 DNS 服务器返回的响应报文。
• 解析响应报文，提取 IP 地址等相关信息。
• 输出阶段： 将解析结果输出到控制台，并在日志中记录详细信息。

5. DNS 协议详细解析

在实现 DNS 解析之前，我们需要了解 DNS 报文的详细格式。下面简单介绍 DNS 报文的主要组成部分。

5.1 DNS 报文头（Header）

DNS 报文头总共 12 字节，主要字段包括：

标识符（ID）： 2 字节，用于匹配请求和响应。

标志（Flags）： 2 字节，包含 QR、Opcode、AA、TC、RD、RA、Z、RCODE 等标志位。

• QR：查询/响应标志（0 表示查询，1 表示响应）。
• Opcode：操作码（通常为 0，即标准查询）。
• AA：权威回答标志。
• TC：截断标志。
• RD：期望递归查询标志。
• RA：递归可用标志。
• RCODE：响应码，表示查询状态（0 为无错误）。

问题数（QDCOUNT）： 2 字节，表示问题部分的记录数。

回答数（ANCOUNT）： 2 字节，表示回答部分记录数。

授权记录数（NSCOUNT）： 2 字节。

附加记录数（ARCOUNT）： 2 字节。

5.2 DNS 问题部分（Question）

问题部分包含查询的域名、查询类型和查询类。域名采用一种特殊格式编码：

例如，“www.example.com” 被编码为：

3www7example3com0

其中数字表示后面字符串的长度，最后一个 0 表示域名结束。

• 查询类型（QTYPE）： 2 字节，常用的 A 记录类型对应 0x0001。
• 查询类（QCLASS）： 2 字节，通常为 0x0001（IN，互联网）。

5.3 DNS 回答部分（Answer）

回答部分包含 DNS 服务器返回的资源记录，其格式与问题部分类似，但包含更多信息，如 TTL（生存时间）、数据长度以及具体的资源数据（例如 IP 地址）。

在本项目中，我们主要关注 A 记录的解析，其资源数据部分为 4 字节 IPv4 地址。

6. Java 实现 DNS 客户端的详细设计

本项目将使用 Java 进行 DNS 客户端的开发，主要涉及以下技术点：

UDP 网络编程：利用 DatagramSocket 与 DatagramPacket 类发送和接收 UDP 数据包，完成 DNS 查询请求与响应数据的传输。

字节数组处理：利用字节数组构造 DNS 查询报文，并通过位运算、数组操作对响应数据进行解析。

域名编码：实现将域名转换为 DNS 协议格式的函数，即将 “www.example.com” 编码为 3www7example3com0。

数据解析：设计解析 DNS 响应报文的逻辑，从中提取 Header 信息、问题部分（可略过校验）和回答部分，重点解析 A 记录资源数据（IP 地址）。

异常处理：包括网络超时、数据格式错误、解析失败等情况，采用 try/catch 机制保证程序健壮性。

6.1 设计模块划分

DNSUtil 类：提供域名编码、16 位整数与字节数组转换等工具函数。

DNSQuery 类：包含构造查询报文、发送查询请求、接收响应报文、解析响应数据的方法。

主程序 Main 类：提供命令行输入接口，调用 DNSQuery 类完成解析流程，并输出解析结果。

7. 实现代码及详细注释

下面给出完整代码，所有核心逻辑均整合到一个 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);
          www.devze.com      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);
            }
        }
    }
}

【详细注释说明】

DNSUtil 类：

• encodeDomainName 方法将输入域名转换为符合 DNS 协议要求的格式，方便后续放入报文中；
• shortToBytes 与 bytesToShort 分别用于整数与字节数组间的转换，确保数据以网络字节序存储。

DNSQuery 类：

• buildQuery 方法构造 DNS 查询报文，包括报文头和问题部分，随机生成的 Transaction ID 用于匹配响应；
• parseResponse 方法解析响应报文，先跳过 Question 部分，再解析 Answer 部分中类型为 A 的记录，从中提取 IPv4 地址；
• resolve 方法整合了查询请求的发送和响应解析逻辑，利用 UDP DatagramSocket 完成整个 DNS 查询流程；
• main 方法作为命令行入口，用户输入待解析域名后调用 resolve 方法，并输出解析结果。

8. 代码解读

本节对关键方法进行解读，帮助读者理解每个部分的功能与设计思想，而不再重复代码内容。

8.1 DNSUtil 类的作用

encodeDomainName 方法：将形如“www.example.com”的字符串分割成各个标签，前置标签长度，末尾添加 0 字节，生成符合 DNS 协议格式的字节序列，便于放入查询报文中。

shortToBytes 与 bytesToShort 方法：这两个方法分别用于将 16 位整数转换为两个字节（网络字节序）和反向转换，保证 DNS 报文中所有整数字段均以大端格式存储和读取。

8.2 DNSQuery 类核心方法

buildQuery 方法：

• 构造 DNS 查询报文时，首先构造 12 字节的 Header，设置随机 Transaction ID、标志位（递归查询）和问题数量等；
• 随后，将用户输入的域名转换成 DNS 格式后追加到报文中，并附上查询类型（A 记录）和查询类（IN）。
• 该方法最终返回一个完整的 DNS 查询字节数组。

parseResponse 方法：

• 解析响应报文时，先依次读取报文头各字段，然后根据问题数跳过 Question 部分。
• 在解析 Answer 部分时，逐条判断记录类型，如果为 A 记录且数据长度为 4 字节，则读取 4 字节 IPv4 地址，并转换为可读的字符串格式。
• 最终将所有解析到的 IP 地址存入列表中返回。

resolve 方法：

• 该方法整合了构造报文、UDP 发送、响应接收及解析整个过程。
• 使用 DatagramSocket 设置超时，确保网络通信稳定，并捕获异常保证程序健壮性。
• 最后返回解析结果列表。

8.3 主函数 main 方法

main 方法：

• 检查命令行参数，调用 resolve 方法开始 DNS 查询，并将解析结果打印到控制台。
• 使整个程序能在命令行下直接运行，便于调试与测试。

9. 测试与运行结果

9.1 测试方法

命令行测试：

• 编译后运行 java DNSQuery www.example.com，观察控制台输出。
• 正常情况下应输出类似“解析结果：IP 地址：93.184.216.34”的信息。

多次测试：

• 更换不同的域名进行测试（如 www.google.com、www.baidu.com 等），验证解析结果是否正确。
• 同时可以利用 Wireshark 观察 UDP 数据包，确认 DNS 查询报文的格式是否正确。

错误处理测试：

输入不存在或格式错误的域名，观察程序是否能捕获异常并输出友好提示。

9.2 运行结果分析

正常返回：

• 当 DNS 查询成功时，程序能够正确解析出响应报文中包含的 IP 地址。
• 多个 A 记录时，将全部输出。

超时或异常：

当网络异常或 DNS 服务器无响应时，程序将捕获异常并输出错误提示，保证系统不崩溃。

10. 项目总结与心得体会

10.1 项目总结

本项目通过 Java 实现了一个简易的 DNS 客户端，从零开始构造 DNS 查询报文，利用 UDP 协议发送请求，并解析 DNS 服务器响应。主要收获如下：

DNS 协议解析：通过手动构造报文和解析响应，深入理解了 DNS 协议中 Header、Question 和 Answer 部分的结构和作用。

UDP 网络编程：掌握了使用 DatagramSocket 发送与接收 UDP 数据包的方法，同时学习了设置超时和异常捕获机制。

字节操作与数据处理：学习了如何通过字节数组与 ByteBuffer 操作数据，android掌握了网络字节序与数据格式转换的基本技巧。

项目扩展性：虽然项目目前只实现了 A 记录的解析，但模块化设计为后续扩展其他记录类型（如 AAAA、MX、CNAME 等）提供了良好基础。

10.2 心得体会

底层协议理解的重要性：通过自己构造 DNS 查询报文，不仅对 DNS 协议有了更直观的认识，也对网络协议设计和数据格式有了深入理解。

代码健壮性设计：在设计过程中，合理利用异常处理和超时机制，使得网络通信更加健壮，能应对各种不可预知的网络情况。

实践与理论结合：实际编码过程中，不仅巩固了网络编程、字节处理等理论知识，同时对调试网络数据包、验证协议格式有了实战体验。

11. 扩展讨论与未来展望

如何扩展项目功能

解析更多记录类型：

• 目前仅解析 A 记录，后续可以扩展解析 AAAA 记www.devze.com录（IPv6 地址）、MX（邮件交换）、CNAME（别名）等。
• 为此需要在解析响应报文时，根据 TYPE 字段分别处理不同数据格式。

支持 TCP 连接：

DNS 查询在某些情况下会使用 TCP（例如响应数据超过 512 字节时），可扩展程序支持 TCP 连接方式。

图形化界面：

基于 Swing 或 JavaFX 实现简单的图形化界面，使用户可以直观输入域名、查看解析结果及报文详细信息。

缓存机制：

可设计 DNS 缓存，在同一域名多次查询时直接返回缓存数据，提高响应速度并降低网络负载。

日志与调试工具：

引入日志框架（如 log4j）记录每次查询的详细过程，便于调试和监控。

12. 附录

完整代码下载与运行说明

将上文完整代码保存为 DNSQuery.java 文件，使用以下命令编译与运行：

javac DNSQuery.java
java DNSQuery www.example.com

观察控制台输出，验证域名解析结果。

常见问题解答

Q：为何使用 UDP 而非 TCP？

A：DNS 协议默认使用 UDP，因为其效率高、开销小；TCP 仅在数据量大或需要可靠传输时使用。

Q：如何调试报文内容？

A：可以在构造报文和解析报文时打印十六进制字符串，借助 Wireshark 捕获网络数据包进行对比分析。

Q：如果解析失败怎么办？

A：检查网络连接、DNS 服务器地址是否正确，并确保域名格式正确；程序中已捕获异常并提供提示。

13. 总结

本文详细介绍了如何利用 Java 从零实现一个简易的 DNS 客户端，内容涵盖了 DNS 协议原理、报文结构、UDP 网络编程、字节数组处理及数据解析方法。通过代码构造与详细注释，读者可以清楚了解每一步的实现思路和关键技术。项目不仅帮助初学者掌握 DNS 解析原理，也为高级网络编程、协议设计提供了有益参考。

从整体架构设计、模块划分，到细致的代码实现和测试验证，本文力求做到结构清晰、层次分明，既满足博客分享的需求，也能作为知识学习的详实资料。未来可在此基础上扩展更多 DNS 功能，或结合其他网络协议进行跨协议数据解析，实现更复杂的网络通信系统。

通过本项目的实践，开发者不仅能够提高 Java 网络编程能力，还能对分布式系统中常用的 DNS 协议及其应用有更深入的认识。这将为后续开发高性能网络应用和分布式系统打下坚实的基础。

以上就是Java实现域名解析的示例详解(附带源码)的详细内容，更多关于Java域名解析的资料请关注编程客栈(www.devze.com)其它相关文章！