Java 网络编程（2）：UDP 的使用

今天的主角是 UDP（User Datagram Protocol，用户数据报协议）。
咱们都知道 TCP 是一种可靠的协议 —— 首先客户端和服务端须要创建链接（三次“握手”），数据发送完毕须要断开链接（四次“挥手”）；若是发送数据时数据损坏或者丢失，那么 TCP 会从新发送。保证可靠的代价就是效率的下降（创建链接和断开链接就须要时间，保证数据的可靠性也须要额外的消耗）。与 TCP 相对应，UDP 是面向无链接的协议，而且它不保证数据是否会到达，也不保证到达的数据是否准确和数据顺序是否正确 —— 因此相比于 TCP， UDP 的速度很快。在 须要不创建链接便可发送数据 的系统，或者 保证最快的传输速度比每一位数据都正确更重要 的系统（如视频会议，丢失某个数据包只是一个画面或者声音的小干扰）中，UDP 才是正确的选择。实际上，在同一个网段，或者在信号很好的局域网，UDP 是很是可靠的。

在 Java 中使用 UDP 时关键的两个类分别是：DatagramSocket 和 DatagramPacket。
DatagramPacket 表示数据包，而 DatagrameSocket 用来发送和接收数据包。

• 发送数据包时：

由于 UDP 协议并不须要创建链接，因此咱们将数据（byte数组）放入 DatagramPacket 以后，还须要将目的地（IP地址和端口）放入到 DatagramPacket 中 —— DatagramSocket 的 send(DatagramPacket packet) 方法根据 packet 中指定目的地，将其包含的数据往这个目的地发送。至于数据是否能（准确）到达目的地，DatagramSocket 并不关心。

• 接收数据包时：

DatagramSocket 在接收数据包时，咱们须要为其指定一个监听的端口。当有包含了接收端机器 IP 地址和 DatagramSocket 所监听端口的数据包到达时，DatagramSocket 的 receive(DatagramPacket packet) 方法便会对数据包进行接收，并将接收到的数据包填入到 packet 中。

如今让咱们来实践 DatagramSocket 和 DatagramPacket：
由于 UDP 没有服务端和客户端之分，因此咱们把两端分别定义为 发送端 和 接收端。
发送端代码：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class UDPSender {

    private static final int RECVER_LISTENING_PORT = 9999;

    public static void main(String[] args) throws Exception {
        List<DatagramPacket> messages = new ArrayList<>(12);
        for (int i = 0; i < 4; i++) {
            String msgBody = (i == 3 ? "" : "Hello UDP-" + i);

            DatagramPacket msg0 = parseMsg(
                    msgBody, "127.0.0.1", RECVER_LISTENING_PORT); // 发送给本机
            DatagramPacket msg1 = parseMsg(
                    msgBody, "192.168.3.3", RECVER_LISTENING_PORT); // 发送给同一局域网的一台机器
            DatagramPacket msg2 = parseMsg(
                    msgBody, "120.77.**.***", RECVER_LISTENING_PORT); // 120.77.**.*** 是我阿里云主机的公网 IP 地址

            // JDK1.5 时 Collections 添加的 addAll 方法，能够一次往某个集合中添加多个元素
            Collections.addAll(messages, msg0, msg2, msg1);
        }

        startSending(messages);
    }

    private static void startSending(List<DatagramPacket> messages)
            throws IOException, InterruptedException {

        // 无参构造的 DatagramSocket 会随机选择一个端口进行监听
        // 由于此时 DatagramSocket 的做用是发送，因此无需显式指定固定端口
        try (DatagramSocket socket = new DatagramSocket()) {
            System.out.println("随机给发送端分配的端口为：" + socket.getLocalPort() + "\n");
            
            for (DatagramPacket msg : messages) {
                socket.send(msg); // 发送数据包

                int recverPort = msg.getPort();
                InetAddress recverAddr = msg.getAddress();
                System.out.printf("消息已经发送 -> (%s:%d)\n",
                        recverAddr.getHostAddress(), recverPort);

                Thread.sleep(500); // 设定 每隔 0.5 秒发送一个消息
            }
        }
    }

    private static DatagramPacket parseMsg(String msgBody, String addr, int port)
            throws UnknownHostException {

        byte[] msgData = msgBody.getBytes();
        DatagramPacket msg = new DatagramPacket(
                msgData, 0, msgData.length, // 数据从位置 0 开始，长度为 msgData.length
                InetAddress.getByName(addr), port); // 目的地 地址为 addr，监听端口为 port

        return msg;
    }

}

接收端代码：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPReceiver {

    private static final int LISTENING_PORT = 9999;
    private static final int BUFFER_SIZE = 512;

    public static void main(String[] args) throws Exception {
        byte[] buffer = new byte[BUFFER_SIZE];
        DatagramPacket msg = new DatagramPacket(buffer, buffer.length);

        try (DatagramSocket socket = new DatagramSocket(LISTENING_PORT)) {
            System.out.println("接收端已经启动...\n");
            while (true) {
                socket.receive(msg); // 接收数据包

                String msgBody = new String(
                        msg.getData(), msg.getOffset(), msg.getLength());
                if (msgBody.isEmpty()) { // 发现接收的消息是空字符串("")便跳出循环
                    break;
                }

                int senderPort = msg.getPort();
                InetAddress senderAddr = msg.getAddress();

                System.out.printf("发送端 地址和端口 -> (%s:%d)\n",
                        senderAddr.getHostAddress(), senderPort);

                System.out.println("发送端 发送的消息 -> " + msgBody + "\n");
            }
        }

        System.out.println("接收端已经关闭。");
    }
}

如今 在本机、同一局域网的一台机器和阿里云主机上都运行 UDPReceiver：

而后启动发送端 UDPSender：

接收端接收结果：

能够看到每一个接收端都正确的接收了发送端发送的消息。

---

（本机 和 局域网机器 显示的发送端的端口(49756)是一致的，可是远程机器即阿里云主机显示的(4802)却与他们不一致——这个问题留给有兴趣的读者本身思考）

---

虽然 UDP 是不可靠的协议，可是由于它不须要创建链接，效率更快，因此在 须要不创建链接便可发送数据 的系统（好比本文的例子），或者 保证最快的传输速度比每一位数据都正确更重要 的系统中，咱们应该使用 UDP。固然，基于 UDP 咱们一样能够开发出可靠的协议——数据包的正确与否能够交给应用程序来判断，若是有问题接收端便提示发送端从新发送。