回显服务器（基于UDP）

谁践踏了优雅 2024-04-25 08:44 64阅读 0赞

**目录**

基本概念

API学习

DatagramSocket

DatagramPacket

InetSocketAddress

回显服务器实现

服务端

思路分析

具体实现

完整代码

客户端

思路分析

具体实现

完整代码

运行测试

--------------------

## 基本概念 ##

**发送端和接收端**

在一次网络数据传输时：

**发送端**：数据的**发送方进程**，称为发送端。发送端主机即网络通信中的**源主机**

**接收端**：数据的**接收方进程**，称为接收端。接收端主机即网络通信中的**目的主机**

（**发送端和接收端是相对的**）

![a6104b31cac94d2b8e49b0ce5df50b85.png][]

**请求和响应**

一般来说，获取一个网络资源，涉及到两次网络数据传输：

> 第一次：**请求**数据的发送
> 
> 第二次：**响应**数据的发送

![e7bed437023a464f902b6d30bafc7b9f.png][]

**服务端和客户端**

**服务端：**在常见的网络数据传输场景下，将提供服务的一方进程，称为服务端，可以提供对外服务

**客户端：**获取服务的一方进程，称为客户端

对于服务来说，一般是提供：

**客户端获取服务资源：**

![bff48fb784a64f858f1454c026164b89.png][]

**客户端保存资源在服务端：**

![884cc546a1c34f4abd602e1fba3f03e1.png][]

**常见的客户端服务端模型：**

最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：

> **（1）客户端先发送请求到服务端**
> 
> **（2）服务端根据请求数据，执行相应的业务处理**
> 
> **（3）服务端返回响应：发送业务处理结果**
> 
> **（4）客户端根据响应数据，展示处理结果（展示获取的资源，或是提示保存资源的处理结果）**

## ![bec74ca6412e4a62af355a6abbac69d0.png][] ##

## API学习 ##

### **DatagramSocket** ###

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

**构造方法：**

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th style="width:212px;">方法</th> 
   <th style="width:286px;">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:212px;">DatagramSocket()</td> 
   <td style="width:286px;">创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）</td> 
  </tr> 
  <tr> 
   <td style="width:212px;">DatagramSocket(int port)</td> 
   <td style="width:286px;">创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）</td> 
  </tr> 
 </tbody> 
</table>

**常用方法：**

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void receive(DatagramPacket p)</td> 
   <td>从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）</td> 
  </tr> 
  <tr> 
   <td>void send(DatagramPacket p)</td> 
   <td>从此套接字发送数据包（不会阻塞等待，直接发送）</td> 
  </tr> 
  <tr> 
   <td>void close</td> 
   <td>关闭此数据报套接字</td> 
  </tr> 
 </tbody> 
</table>

### **DatagramPacket** ###

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

**构造方法：**

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DatagramPacket(byte[] buf, int length)</td> 
   <td>构造一个DatagramPacket用来接收数据报，接收的数据保存在字节数组（buf）中，接收指定长度（length）</td> 
  </tr> 
  <tr> 
   <td>DatagramPacket(byte[] buf, int length, SocketAddress address)</td> 
   <td>构造一个DatagramPacket用来发送数据报，发送的数据在字节数组（buf），发送指定长度（length），address指定目的主机的IP地址和端口号</td> 
  </tr> 
  <tr> 
   <td>DatagramPacket(byte[] buf, int int length, InentAddress, int port)</td> 
   <td>构造一个DatagramPacket用来发送数据报，发送的数据保存在字节数组（buf），发送指定长度（length）到address主机的port端口</td> 
  </tr> 
 </tbody> 
</table>

**常用方法：**

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>InetAddress getAddress()</td> 
   <td>从接收的数据报中，获取发送端主机IP地址和端口号；或从发送的数据报中，获取接收端主机IP地址和端口号</td> 
  </tr> 
  <tr> 
   <td>int getPort()</td> 
   <td>从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号</td> 
  </tr> 
  <tr> 
   <td>byte[] getData()</td> 
   <td>获取数据报中的数据</td> 
  </tr> 
 </tbody> 
</table>

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

### **InetSocketAddress** ###

**InetSocketAddress（SocketAddress的子类）构造方法：**

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>InetSocketAddress(InetAddress addr, int port)</td> 
   <td>创建一个Socket地址，包含IP地址和端口号</td> 
  </tr> 
 </tbody> 
</table>

## **回显服务器实现** ##

回显服务器的业务逻辑较为简单，通过编写回显服务器，我们能够进一步熟悉相关API和编写流程

服务器接收客户端的请求，返回响应，响应的内容是客户端发送的请求内容（即客户端发什么，服务端响应什么）

其中，涉及到客户端和服务端，我们先实现服务端相关逻辑

## 服务端 ##

### 思路分析 ###

对于服务器，要实现的内容有：

> **1. 接收客户端发送的请求**
> 
> **2. 读取解析请求，并根据请求计算响应**
> 
> **3. 将响应返回给客户端**

在实现服务器过程中我们需要注意的是，由于服务器要等到客户端发送请求时才能进行接收、解析、计算响应等操作，而服务器不知道客户端什么时候发送请求，因此服务器需要一直“待命”，等待客户端发送请求

### 具体实现 ###

**首先我们需要创建一个 DatagramSocket 对象用于接收UDP数据报，并通过构造方法来指定服务器要绑定的端口号**

import java.net.DatagramSocket;
    import java.net.SocketException;
    
    public class UdpEchoServer {
        DatagramSocket socket = null; //创建 DatagramSocket 对象用于发送和接收UDP数据报
        public UdpEchoServer(int port) throws SocketException {
            socket = new DatagramSocket(port);
        }
    }

**接下来，我们实现服务器的启动，接收客户端发送的请求并解析**

//启动服务器
        public void start() throws IOException {
            System.out.println("启动服务器");
            while (true) {//服务器需要长期、返回地接收请求、处理请求
                // 接收请求并解析
                //创建 DatagramPacket 对象用于接收客户端发送的数据报
                DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
                //接收请求数据报
                socket.receive(requestPacket);
                //将读取到的字节数组转换成String 方便后续逻辑处理
                String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
                
            }
        }

其中的receive()能够读取到一个UDP数据报，并将其放到requestPacket中，其中，UDP数据报的载荷部分被放到requestPacket内置的字节数组中，而报头部分，则会被requestPacket的其他属性保存。在执行到receive()时，若还没有客户端发来请求，则会先阻塞等待，直到接收到客户端发送的请求

**接下来，根据请求计算响应，对于回显服务器，这一步非常简单，只需要将请求内容直接作为响应内容即可**

//启动服务器
        public void start() throws IOException {
            System.out.println("启动服务器");
            while (true) {//服务器需要长期、反复地接收请求、处理请求
               // 接收请求并解析
                //创建 DatagramPacket 对象用于接收客户端发送的数据报
                DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
                //接收请求数据报
                socket.receive(requestPacket);
                //将读取到的字节数组转换成string 方便后续逻辑处理
                String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
    
                //根据请求计算响应
                String response = process(request);
            }
        }
        public String process(String request){
            return request;
        }

基于字节数组构造出String，字节数组中保存的内容不一定是二进制数据，也可能是文件数据，而String既可以保存文本数据也可以保存二进制数据

**最后，我们将响应返回到客户端**

//将响应返回给客户端
                //构造 DatagramPacket 对象用于存储向客户端发送响应内容
                DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                        requestPacket.getSocketAddress()); //此时需要传入发送数据的字节数组、数据长度和发送请求的客户端的IP地址和端口号
                //发送响应数据报
                socket.send(requestPacket);

在发送请求时，将请求中的源IP和源端口号，作为响应的目的IP和目的端口号，此时就能够将消息返回给客户端

**为了方便观察程序的执行效果，我们可以打印日志**

### **完整代码** ###

import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    public class UdpEchoServer {
        DatagramSocket socket = null;//创建 DatagramSocket 对象用于发送和接收UDP数据报
        public UdpEchoServer(int port) throws SocketException {
            socket = new DatagramSocket(port);
        }
    
        //启动服务器
        public void start() throws IOException {
            System.out.println("启动服务器");
            while (true) {//服务器需要长期、反复地接收请求、处理请求
                // 接收请求并解析
                //创建 DatagramPacket 对象用于接收客户端发送的数据报
                DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
                //接收请求数据报
                socket.receive(requestPacket);
                //将读取到的字节数组转换成string 方便后续逻辑处理
                String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
    
                //根据请求计算响应
                String response = process(request);
    
                //将响应返回给客户端
                //构造 DatagramPacket 对象用于存储向客户端发送响应内容
                DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                        requestPacket.getSocketAddress()); //此时需要传入发送数据的字节数组、数据长度和发送请求的客户端的IP地址和端口号
                //发送响应数据报
                socket.send(requestPacket);
                //打印日志
                System.out.printf("[%s:%d] req: %s, resp: %s\n", responsePacket.getAddress().toString(), responsePacket.getPort(),
                        request, response);
            }
        }
        public String process(String request){
            return request;
        }
    }

接下来，我们运行服务器：

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

由于服务器要等待客户端发送请求后才能执行后续操作，因此，我们先实现客户端后再来观察效果

实现服务器后，我们接着实现客户端相关操作

## 客户端 ##

### 思路分析 ###

对于服务端要实现的内容有：

> **1. 从控制台读取用户输入的内容**
> 
> **2. 将内容构造成UDP请求，并发送给服务器**
> 
> **3. 等待服务器响应，当接收到服务器响应时，解析响应内容**
> 
> **4. 将响应内容显示到屏幕上**

### 具体实现 ###

**首先，我们要创建一个 DatagramSocket 对象用于接收UDP数据报，但此时不需要手动指定端口号**

import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    public class UdpEchoClient {
        private DatagramSocket socket = null;
        private String serverIp;//服务器IP
        private int serverPort;//服务器端口号
        public UdpEchoClient(String serverIp, int serverPort) throws SocketException {
            this.serverIp = serverIp;
            this.serverPort = serverPort;
            socket = new DatagramSocket();
        }
    }

由于我们要知道服务器的IP地址和端口才能向其发送请求，因此，在这里我们通过构造方法来指定服务器的IP和端口号

> **为什么服务器需要指定端口号，而客户端则是不需要？**

> 对于服务器，需要手动指定端口，对于客户端，则一般不用手动指定，此时系统会自动分配一个空闲的端口号。这是因为对于客户端来说，无法保证手动指定的端口是可用的，因此由系统随机分配一个空闲的端口号，而对于服务器端口来说，我们事先知道服务器上有哪些端口被使用，因此我们可以确保指定的端口未被占用，此外，客户端要主动给服务器发起请求，通过服务器端口号找到服务器，若服务器端口号也随机分配，则客户端不能找到服务器

**接下来我们启动服务器，并从控制台读取要发送的请求数据**

//启动服务器
        public void start(){
            System.out.println("启动客户端");
            Scanner scanner = new Scanner(System.in);
            while (true){
                System.out.print("请输入:");
                if(!scanner.hasNext()){
                   break; 
                }
                String request = scanner.next();
                
            }
        }

**接下来，我们由输入的内容构造请求并发送**

//启动服务器
        public void start() throws IOException {
            System.out.println("启动客户端");
            Scanner scanner = new Scanner(System.in);
            while (true){
                System.out.print("请输入:");
                if(!scanner.hasNext()){
                   break;
                }
                String request = scanner.next();
                //构造请求并发送
                DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                        request.getBytes().length, InetAddress.getByName(serverIp), serverPort);
                socket.send(requestPacket);
            }
        }

由于数据报需要进行发送，因此需要有目的主机的IP地址和端口号，而构造方法中传入的IP地址是字符串类型，且是点分十进制风格的（例如“127.0.0.1”），因此我们需要使用 InetAddress.getByName 创建InetAddress对象

**然后我们需要读取服务器返回的响应并显示**

//读取服务器返回的响应
                DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(responsePacket);
                //将响应显示到控制台上
                String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
                System.out.println(response);

接着我们运行客户端：

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

### 完整代码 ###

import java.io.IOException;
    import java.net.*;
    import java.util.Scanner;
    
    public class UdpEchoClient {
        private DatagramSocket socket = null;
        private String serverIp;//服务器IP
        private int serverPort;//服务器端口号
        public UdpEchoClient(String serverIp, int serverPort) throws SocketException {
            this.serverIp = serverIp;
            this.serverPort = serverPort;
            socket = new DatagramSocket();
        }
        //启动服务器
        public void start() throws IOException {
            System.out.println("启动客户端");
            Scanner scanner = new Scanner(System.in);
            while (true){
                System.out.print("请输入:");
                if(!scanner.hasNext()){
                   break;
                }
                String request = scanner.next();
                //构造请求并发送
                DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                        request.getBytes().length, InetAddress.getByName(serverIp), serverPort);
                socket.send(requestPacket);
                //读取服务器返回的响应
                DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(responsePacket);
                //将响应显示到控制台上
                String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
                System.out.println(response);
            }
        }
    
        public static void main(String[] args) throws IOException {
            UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9010);
            client.start();
        }
    }

## 运行测试 ##

此时，我们同时运行服务器和客户端，并输入请求观察代码是否存在问题：

客户端：

![e3acdc5ef49b4166a1226b0886ba0fa2.png][]

服务器：

![c6b2f9ebed6f45c69846c1969e329667.png][] 此时我们看到，客户端输入的请求后响应成功显示，且服务器记录日志正确

[a6104b31cac94d2b8e49b0ce5df50b85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/9b9f047854fe4be8849dd8159e623fc9.png
[e7bed437023a464f902b6d30bafc7b9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/05131f0d5d68460cbf91b347ef6cab91.png
[bff48fb784a64f858f1454c026164b89.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/1cda6bc05a5740a5a937e225011ff349.png
[884cc546a1c34f4abd602e1fba3f03e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/210167ec7a88415193a5b95a34b916f8.png
[bec74ca6412e4a62af355a6abbac69d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/158feb77b41442e99ef12c0b4e505a12.png
[e3acdc5ef49b4166a1226b0886ba0fa2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/cdb0a56d15c24e0f84b2eef2b24aa1cd.png
[c6b2f9ebed6f45c69846c1969e329667.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/c3b91f6b3a5b48e18febf84cd0335720.png