Java基于UDP实现简单客户端与服务器通信的网络原理

目录

我们用Java实现UDP数据报套接字编程，需要借用以下API来实现

🎄API介绍

🌸DatagramSocket

网络编程, 本质上是要操作网卡.

但是网卡不方便直接操作. 在操作系统内核中, 使用了一种特殊的叫做 “socket” 这样的文件来抽象表示网卡.

因此进行网络通信, 势必需要先有一个 socket 对象.

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

DatagramSocket 构造方法：

对于服务器来说, 创建 socket 对象的同时, 要让他绑定上一个具体的端口号.

服务器一定要关联上一个具体的端口的!!!

服务器是网络传输中, 被动的一方. 如果是操作系统随机分配的端口, 此时客户端就不知道这个端口是啥了, 也就无法进行通信了!!!

而做为客户端，可能客户并不知道自己那个端口什么时候空闲，如果强行指定，则可能会出现问题，所以我们选择绑定任意随机端口。

DatagramSocket ⽅法：

🌸DatagramPacket

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

DatagramPacket 构造⽅法：

这个就相当于你去食堂吃饭需要拿个盘子装饭一样，这个就是拿来装数据报的

DatagramSocket也提供了以下几种方法供我们使用

DatagramPacket 方法：

构造UDP发送的数据报时，需要传⼊ SocketAddress ，该对象可以使⽤ InetSocketAddress
来创建。

🌸InetSocketAddress

InetSocketAddress （ SocketAddress 的⼦类 ）构造⽅法：

🌳回显客户端与服务器

什么叫回显客户端与与服务器呢？

其实就是：客户端向服务端发送请求，一般来说我们的服务端会对我们发送的请求进行处理，我们这里为了简单，就省略里面的处理过程，只实现将请求重新发回客户端，不做任何处理。

🌸建立回显服务器

我们大致可以分为以下几步

1. 创建一个类，为UdpEchoServer，来表示我们的UDP 版本的回显服务器
2. 创建一个socket对象，来操作网卡
3. 在UdpEchoServe类的构造方法里对socket对象进行构造
4. 建立start()方法用于启动我们的服务器
5. 由于我们的服务器需要长期开着，所以我们设计一个死循环
6. 构造好个空白的 DatagramPacket 对象. 交给 receive 来进行填充
7. DatagramPacket 是一个特殊的对象, 并不方便直接进行处理. 可以把这里包含的数据拿出来, 构造成一个字符串.
8. 创建一个process()方法，这个方法就表示 “根据请求计算响应”
9. 把响应写回到客户端. send 的参数也是 DatagramPacket. 需要把这个 Packet 对象构造好.此处构造的响应对象,
   不能是用空的字节数组构造了, 而是要使用响应数据来构造
10. 我们加一个打印一下,当前这次请求响应的处理中间结果
11. 最后我们创建main()函数进行启动，创建UdpEchoServer对象传入端口号，端口号为自己指定的，只要在1024 -> 65535这个范围里随便挑个数字就行了

接下来我们一起来看看代码的实现：

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

// UDP 版本的回显服务器
public class UdpEchoServer {
    // 网络编程, 本质上是要操作网卡.
    // 但是网卡不方便直接操作. 在操作系统内核中, 使用了一种特殊的叫做 "socket" 这样的文件来抽象表示网卡.
    // 因此进行网络通信, 势必需要先有一个 socket 对象.
    private DatagramSocket socket = null;

    // 对于服务器来说, 创建 socket 对象的同时, 要让他绑定上一个具体的端口号.
    // 服务器一定要关联上一个具体的端口的!!!
    // 服务器是网络传输中, 被动的一方. 如果是操作系统随机分配的端口, 此时客户端就不知道这个端口是啥了, 也就无法进行通信了!!!
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        // 服务器不是只给一个客户端提供服务就完了. 需要服务很多客户端.
        while (true) {
            // 只要有客户端过来, 就可以提供服务.
            // 1. 读取客户端发来的请求是啥.
            //    receive 方法的参数是一个输出型参数, 需要先构造好个空白的 DatagramPacket 对象. 交给 receive 来进行填充.
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);
            // 此时这个 DatagramPacket 是一个特殊的对象, 并不方便直接进行处理. 可以把这里包含的数据拿出来, 构造成一个字符串.
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
            // 2. 根据请求计算响应, 由于此处是回显服务器, 响应和请求相同.
            String response = process(request);
            // 3. 把响应写回到客户端. send 的参数也是 DatagramPacket. 需要把这个 Packet 对象构造好.
            //    此处构造的响应对象, 不能是用空的字节数组构造了, 而是要使用响应数据来构造.
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);
            // 4. 打印一下, 当前这次请求响应的处理中间结果.
            System.out.printf("[%s:%d] req: %s; resp: %s\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }
    }

    // 这个方法就表示 "根据请求计算响应"
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        // 端口号的指定, 大家可以随便指定.
        // 1024 -> 65535 这个范围里随便挑个数字就行了.
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

🌸回显客户端

我们分为以下几步：

1. 我们创建一个类UdpEchoClient来表示客户端服务。
2. 创建socket对象，来操作网卡
3. 定义两个变量，一个表示服务器的IP地址，一个表示端口号
4. 在UdpEchoClient的构造方法里进行构造
5. 构造成 UDP 请求, 并发送，构造这个 Packet 的时候, 需要把 serverIp 和 port 都传入过来. 但是此处 IP地址需要填写的是一个 32位的整数形式.上述的 IP 地址是一个字符串. 需要使用InetAddress.getByName来进行一个转换.
6. 读取服务器的 UDP 响应, 并解析，构造好个空白的 DatagramPacket 对象. 交给 receive 来进行填充
7. 把解析好的结果显示出来.
8. 创建main函数，创造UdpEchoClient对象，并把服务器的IP和端口给传进去
9. 启动服务器

代码实现如下：

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

// UDP 版本的 回显客户端
public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp = null;
    private int serverPort = 0;

    // 一次通信, 需要有两个 ip, 两个端口.
    // 客户端的 ip 是 127.0.0.1 已知.
    // 客户端的 port 是系统自动分配的.
    // 服务器 ip 和 端口 也需要告诉客户端. 才能顺利把消息发个服务器.
    public UdpEchoClient(String serverIp, int serverPort) throws SocketException {
        socket = new DatagramSocket();
        this.serverIp = serverIp;
        this.serverPort = serverPort;
    }

    public void start() throws IOException {
        System.out.println("客户端启动!");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 从控制台读取要发送的数据
            System.out.print("> ");
            String request = scanner.next();
            if (request.equals("exit")) {
                System.out.println("goodbye");
                break;
            }
            // 2. 构造成 UDP 请求, 并发送
            //    构造这个 Packet 的时候, 需要把 serverIp 和 port 都传入过来. 但是此处 IP 地址需要填写的是一个 32位的整数形式.
            //    上述的 IP 地址是一个字符串. 需要使用 InetAddress.getByName 来进行一个转换.
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            // 3. 读取服务器的 UDP 响应, 并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            // 4. 把解析好的结果显示出来.
            System.out.println(response);
        }
    }

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

客户端

服务端

⭕总结

关于《【网络原理】使用Java基于UDP实现简单客户端与服务器通信》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！

作者：山顶是一定要去的