网络多线程——UDP网络通信编程

基本介绍

1. 类 DatagramSocket【数据报套接字】 和 DatagramPacket【数据包 / 数据报】 实现了基于 UDP协议网络程序。
2. UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
3. DatagramPacket 对象封装了 UDP 数据报，在数据报中包含了发送端的 IP 地址和端口号以及接收端的 IP 地址和端口号。
4. UDP 协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

UDP 网络编程原理示意图

基本流程

1. 核心的两个类/对象 DatagramSocket 与 DatagramPacket
2. 建立发送端，接收端（没有服务端和客户端概念）
3. 发送数据前，建立数据包/报 DatagramPacket 对象
4. 调用 DatagramSocket 的发送、接收方法
5. 关闭 DatagramSocket

应用案例

1. 编写一个接收端A，和一个发送端B
2. 接收端A 在 9999 端口等待接收数据（receive）
3. 发送端B 向接收端A 发送数据 “hello，明天吃火锅~”
4. 接收端A 接收到发送端B 发送的数据，回复 “好的，明天见”，再退出
5. 发送端接收回复的数据，再退出

接收端 A

package net.udp;

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

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 14:24 2021/10/12
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个 DatagramSocket 对象，准备在 9999 接收数据
        DatagramSocket datagramSocket = new DatagramSocket(9999);
        // 2. 创建一个 DatagramPacket 对象，准备接收数据
        //    UDP协议：每个数据包的大小限制在 64K 内，不适合传输大量数据
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buf, buf.length);
        // 3. 调用接收方法，将通过网络传输的 DatagramPacket 对象填充到 datagramPacket
        //    当有数据包发送到本机的 9999 端口时，就会接收到数据
        //    如果没有数据包发送到本机的 9999 端口，就会阻塞
        System.out.println("接收端 A 等待接收数据....");
        datagramSocket.receive(datagramPacket);
        // 4. 可以把 datagramPacket 进行拆包，取出数据，并显示
        int length = datagramPacket.getLength(); // 实际接收到的数据的字节长度
        byte[] data = datagramPacket.getData(); // 接收到的数据
        String s = new String(data, 0, length);
        System.out.println(s);

        //===========回复信息给 B 端===========
        // 5. 将要发送的数据封装到 DatagramPacket 对象中
        byte[] bytes = "好的，明天见".getBytes();
        DatagramPacket datagramPacket1
                = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("10.25.135.233"), 9998);

        // 6. 通过 DatagramSocket 对象发送数据
        datagramSocket.send(datagramPacket1);
        // ===========回复信息给 B 端============

        // 7. 关闭资源
        datagramSocket.close();
        System.out.println("接收端A 退出~~~");

    }
}

发送端 B

package net.udp;

import java.io.IOException;
import java.net.*;

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 14:25 2021/10/12
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {

        // 1. 创建 DatagramSocket 对象，准备在 9998 端口接收数据
        DatagramSocket datagramSocket = new DatagramSocket(9998);
        // 2. 将需要发送的数据封装到 DatagramPacket 对象中
        byte[] data = "hello，明天吃火锅~".getBytes();
        DatagramPacket datagramPacket
                = new DatagramPacket(data, data.length, InetAddress.getByName("10.25.135.233"), 9999);
        // 3. 通过 DatagramSocket 对象发送数据
        datagramSocket.send(datagramPacket);


        // ========接收 A 端的回复信息========
        // 4. 创建 DatagramPacket 对象，准备接受数据
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket1 = new DatagramPacket(buf, 0, buf.length);
        System.out.println("B 端等待接收 A 端回复的数据...");
        datagramSocket.receive(datagramPacket1);

        // 5. 把 datagramPacket1 进行拆包，取出数据并显示
        int length = datagramPacket1.getLength();
        byte[] data1 = datagramPacket1.getData();
        String s = new String(data1, 0, length);
        System.out.println(s);
        // ========接收 A 端回复的信息========


        // 6. 关闭资源
        datagramSocket.close();
        System.out.println("发送端B 退出~~~");
    }
}