前言： 通过写一个简单的服务器来了解 UDP 的常用API

目录

• • UDP服务器程序
  • UDP客户端程序
  • 客户端角度理解五元组
  • 总结

面向数据报 (发送接收数据，必须以一定的数据包为单位进行传输)
使用传输层 UDP 协议

UDP服务器程序

对于一个服务器程序来说，核心流程分为两步：
1.初始化 (实例化 Socket 对象)
2.进入主循环, 接收并处理请求 (主循环就是一个"死循环")

• a) 读取数据并解析
• b) 根据请求计算响应
• c) 把响应结果写到客户端

此处以一个 echo server 为例：
最简单的客户端服务器
客户端给服务器发送一个字符串，服务器把该字符串原封不动的返回(回显服务器 echo server)
相当于服务器开发中的"Hello World！"

1.初始化操作：

private DatagramSocket socket = null;

// 构造方法
public UdpEchoServer(int port) throws SocketException {
    socket = new DatagramSocket(port);
}

此处的构造方法就是 new 了一个 socket 对象
new 这个socket对象的时候，就会让当前的 socket对象和一个IP地址，以及一个端口号关联起来 (绑定端口)
.
构造 socket 的时候，若没写IP，就默认是 0.0.0.0(特殊IP)，会关联到这个主机的所有网卡的IP，一般写服务器都是用全0IP
socket 对象，本质上是一个文件；这个文件是网卡的抽象

2.在主循环里接收并处理请求

• ① 读取数据并解析

DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
// 创建了一个 DatagramPacket 对象，且给该对象 关联了一个缓冲区

socket.receive(requestPacket); 

String request = new String(requestPacket.getData(),
        0, requestPacket.getLength()).trim();

DatagramPacket 是UDP Socket 发送和接收的数据报
程序一启动，马上就能执行到 receive
.
思考：服务器启动了之后，客户端也发送请求了吗？？
答： 不是，客户端啥时候发送请求，无法确定…
大概率的情况是，调用 receive 的时候，客户端还没发送任何数据，此时 receive 操作就会阻塞等待，一直阻塞到，真的有数据了为止；当真的有客户端的数据过来了之后，此时 receive 就会把收到的数据放到 DatagramPacket 对象的缓冲区中

String request = new String(requestPacket.getData(),
        0, requestPacket.getLength()).trim();

此处是要把请求数据转成一个 String （本来请求是一个 byte[ ]）
调String的trim方法原因： 用户实际发送的数据可能远远小于 4096， 而此处getLength 得到的长度就是 4096，通过 trim 就可以"干"掉不必要的空白字符~

• ② 根据请求计算响应

String response = process(request);

public String process(String request) {
    return request;
}

由于此处是一个 echo server, 请求内容是啥，响应内容就是啥
若是一个更复杂的服务器，此处就需要包含更多的业务逻辑来进行具体的运算

• ③ 把响应结果写到客户端

DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
        response.getBytes().length,requestPacket.getSocketAddress());
        
socket.send(responsePacket);

响应数据就是 response，需要包装成一个 packet 对象
.
response.getBytes( ).length，此处不能写成 response.length( )，这样得到的就是字符数量了；
而正确写法得到的是 字节数
.
requestPacket.getSocketAddress( ) 表示，这个包待会儿要发给谁(目的IP 和 端口 是谁?)，此处的地址就是客户端的端口和地址，这两个信息被包含在 requestPacket 内部

若 packet 用于 receive，只指定缓冲区就可以了(地址是接收数据的时候由内核填充的)
若 packet 用于 send，除了指定缓冲区，还需要指定发送给谁(用户手动设定)
设定方式：
①直接设定 InetAddress 对象(里面同时包含了IP 和 port)
②把 IP 和 port 分开设置

完整代码:

// 服务器
public class UdpEchoServer {
    private DatagramSocket socket = null;

    // 此处的构造方法就是 new 了一个 socket 对象
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    // 启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true){
            // a) 读取数据并解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096); 
            socket.receive(requestPacket); // 程序一启动，马上就能执行到 receive
            String request = new String(requestPacket.getData(),
                    0, requestPacket.getLength()).trim();
            // b) 根据请求计算响应
            String response = process(request);
            // c) 把响应结果写到客户端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
                    response.getBytes().length,requestPacket.getSocketAddress());
            socket.send(responsePacket);

            // 打印一个输出日志
            System.out.printf("[%s:%d] req: %s,resp: %s\n",
                    requestPacket.getAddress().toString(),
                    requestPacket.getPort(),
                    request,
                    response);
        }
    }

    public String process(String request) {
        // 由于此处是一个 echo server, 请求内容是啥，响应内容就是啥
        return request;
    }

    public static void main(String[] args) throws IOException {
        UdpEchoServer server = new UdpEchoServer(6060);
        server.start();
    }
}

UDP客户端程序

客户端主要流程，分成四步骤:
1.从用户那里读取输入的数据
2.构造请求发送给服务器
3.从服务器读取响应
4.把响应写回给客户端

private DatagramSocket socket = null;
private String serverIP;
private int serverPort;

// 需要在启动客户端的时候来指定需要连接哪个服务器
public UdpEchoClient(String serverIP,int serverPort) throws SocketException {
    this.serverIP = serverIP;
    this.serverPort = serverPort;
    // 构造客户端的 socket 时，不需要绑定端口号
    socket = new DatagramSocket();
}

服务器必须绑定端口号
客户端必须不绑定端口号(由操作系统自动分配一个空闲端口)
一个端口号通常情况下，只能被一个进程绑定
服务器绑定了端口之后，客户端才能访问
客户端不能绑定的原因：若客户端绑定了的话，一个主机上就只能启动一个客户端了

1.从用户那里读取输入的数据

Scanner scan = new Scanner(System.in);

System.out.println("-> ");
String request = scan.nextLine();
if(request.equals("exit")){
    break;
}

2.客户端构造请求发送给服务器

DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
        request.getBytes().length, InetAddress.getByName(serverIP),serverPort);
socket.send(requestPacket);

3.从服务器读取响应

DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
socket.receive(responsePacket);
String response = new String(responsePacket.getData(),0,responsePacket.getLength()).trim();

这个代码和服务器读取请求的代码时一模一样的

4.显式响应数据

System.out.println(response);

完整代码:

// 客户端
public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;

    // 需要在启动客户端的时候来指定需要连接哪个服务器
    public UdpEchoClient(String serverIP,int serverPort) throws SocketException {
        this.serverIP = serverIP;
        this.serverPort = serverPort;
        // 构造客户端的 socket 时，不需要绑定端口号
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        Scanner scan = new Scanner(System.in);
        while (true){
            // 1.从用户那里读取输入的数据
            System.out.println("-> ");
            String request = scan.nextLine();
            if(request.equals("exit")){
                break;
            }
            // 2.客户端构造请求发送给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                    request.getBytes().length, InetAddress.getByName(serverIP),serverPort);
            socket.send(requestPacket);
            // 3.从服务器读取响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength()).trim();
            // 4.把响应写回给客户端 显式响应数据
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1",6060);
        client.start();
    }
}

补充：
127.0.0.1 是一个特殊的IP —— 环回IP，自己访问自己
服务器和客户端都在同一台主机上，客户端写的IP就是环回IP
若不在同一台主机上，此处的IP就要写成服务器IP

6060，这个端口要和服务器绑定的端口相匹配

客户端角度理解五元组

协议类型: UDP
源IP: 客户端的IP(客户端所在的主机IP)
源端口: 客户端的端口(操作系统自动分配的端口)
目的IP: 服务器IP (服务器和客户端在同一个主机上，IP 就是127.0.0.1)
目的端口: 6060 (服务器启动时绑定的端口)

运行演示:
同时运行服务器程序和客户端程序

再次启动客户端，就会发现客户端的端口号发生了变化~

网络编程的目的：跨主机通信
但是此时并没有跨主机

总结

服务器：

1. 先初始化
2. 进入主循环
   a)读取请求并解析
   b)根据请求计算响应
   c)把响应写回客户端
   .

客户端：

1. 先初始化
2. 进入主循环
   a)读取用户输入
   b)构造请求并发送给服务器
   c)读取服务器的响应
   d)把响应显示到界面上

画图理解：

注意：
构造的 packet 对象，
若用于 receive，只指定缓冲区就可以了(地址是接收数据的时候由内核填充的)
若用于 send，除了指定缓冲区，还需要指定发送给谁(用户手动设定，指定IP)

若 receive 接收到的数据 大于 缓冲区的大小：
对于 UDP 来说：数据就会截断 (多出来的数据就没了~)

方法总结：

1. DatagramSocket API

DatagramSocket 是 UDP Socket，用于发送和接收UDP数据报

• DatagramSocket 构造方法：

方法签名	方法说明
DatagramSocket( )	创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）
DatagramSocket(intport)	创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）

• DatagramSocket 方法：

方法签名	方法说明
void receive(DatagramPacket p)	从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacketp)	从此套接字发送数据报包（不会阻塞等待，直接发送）
void close( )	关闭此数据报套接字

2. DatagramPacket API

DatagramPacket 是 UDP Socket发送和接收的数据报

• DatagramPacket 构造方法：

方法签名	方法说明
DatagramPacket (byte[ ]buf, int length)	构造一个DatagramPacket 以用来接收数据报，接收的数据保存在字节数组 (第一个参数buf) 中，接收指定长度 (第二个参数 length）
DatagramPacket (byte[ ]buf, int offset, int length,SocketAddress address)	构造一个 DatagramPacket 以用来发送数据报，发送的数据为字节数组 (第一个参数buf) 中，从0到指定长度 (第二个参数length) ，address指定目的主机的 IP 和端口号

• DatagramPacket 方法：

方法签名	方法说明
InetAddressgetAddress()	从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort( )	从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[ ] getData( )	获取数据报中的数据

3. InetSocketAddress API

• InetSocketAddress ( SocketAddress 的子类 ) 构造方法：

方法签名	方法说明
InetSocketAddress(InetAddress addr, int port)	创建一个Socket地址，包含IP地址和端口号