Java之TCP和UDP进行网络编程

雨点打透心脏的1/2处 2024-04-20 14:30 19阅读 0赞

**目录**

一.网络编程

1.1网络编程的作用

1.2网络编程的基本概念

1.3网络编程的实现

二.UDP网络编程

2.1UDP数据报套的初步了解

2.2Java数据报套接字通信模型

2.3Java编程实现UDP通信

三.TCP网络编程

3.1TCP流套接字api

3.2TCP通信代码实现

3.2.1短连接实现代码

3.2.2长连接实现代码

四.总结

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

> 🎁[个人主页][Link 1]：[tq02的博客\_CSDN博客-C语言,Java,Java数据结构领域博主][tq02_CSDN_-C_Java_Java]  
> 🎥 本文由 tq02 原创，首发于 CSDN🙉  
> 🎄 本章讲解内容：**TCP和UDP的编程讲解**
> 
> ![8b2f24dd1be24d1b8dc9ed5daef97b3a.png][]
> 
> 🎥学习专栏： [ C语言][C] [JavaSE][] [MySQL基础][MySQL] [多线程学习][Link 2]

## 一.网络编程 ##

### 1.1网络编程的作用 ###

> 网络编程：指网络上的主机，通过**不同的进程**，以编程的方式实现**网络通信（或称为网络数据传输）**
> 
> 换句话说：通过网络编程可以进行网络资源的数据传输，例如：腾讯视频观看网络电视

![25af2bbd964248a3ad8ffcc7130da073.png][]

### **1.2网络编程的基本概念**  ###

在一次网络数据传输时：

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

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

**收发端**：发送端和接收端两端，也简称为收发端。

注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念

> **网络数据传输的请求和响应**
> 
> 一般而言，获取一个网络资源需要涉及到两次的网络数据传输：
> 
> 1.  请求数据的发送 -----客户端
> 2.  响应数据的发送 ------服务端
> 
> 注：客户端将资源保存在服务端，例如设置密码，将密码保存在服务端，这样即使换台客户端也能登陆。

![ff3a312724f64b59a1cafd1923008189.png][]

### 1.3网络编程的实现 ###

网络编程的实现是通过Socket套接字，由系统供用于网络通信的技术，将传输层协议划主要划分为两类：TCP协议和UDP协议。因此TCP和UDP是网络资源数据传输的重要协议

重点：牢记Socket套接字。TCP和UDP都有其api，通过这个可以进行网络编程。

## 二.UDP网络编程 ##

### 2.1UDP数据报套的初步了解 ###

在Java当中，实现UDP协议的通信的类是-----DatagramSocket（Socket对象），DatagramPacket（udp数据报）

*  DatagramPacket（udp数据报）：将需要的传输数据写入其中，传输后也需要该类接收数据。
 *  DatagramSocket（Socket对象）：发送和接收udp数据报。

![5f649cecb98b4a119025ab77bf86fe8c.png][]

### 2.2Java数据报套接字通信模型 ###

java中使用UDP协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使用

DatagramPacket  作为发送或接收的 UDP 数据报。对于**一次发送及接收** **UDP** **数据报**的流程如下：

![e5872a62b6fd4a6f8a13821a24ba2707.png][]

1.  发送端：使用DatagramPacket类构造发送的内容，由DatagramSocket发送出去。
2.  接收端：使用DatagramPacket类保存接收的数据，由DatagramSocket接收该类。

> 注：在实际情况下，服务器需要提供多个客户端的请求处理及响应。
> 
> 流程图如下：

![29e3d642cecd4a91bd6c2ac367ab7c46.png][]

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

### 2.3Java编程实现UDP通信 ###

在编程之前，我们先要了解两个类---- **DatagramPacket和DatagramSocket。**

**注：服务器相当于家，客户端相当于你，当你想回家时，我们需要得到服务器的地址(IP地址），门牌号(端口号）**

**（1）DatagramPacket**

构造方法

<table> 
 <tbody> 
  <tr> 
   <td>构造方法</td> 
   <td>方法说明</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">DatagramPacket(byte[] </span> 
    </div> 
    <div> 
     <span style="color:#333333;">buf, int length) </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#fe2c24;">接收数据报</span> 
     <span style="color:#333333;">，接收的数据保存在字节数组（第一个参数buf</span> 
     <span style="color:#333333;">）中，接收指定长度</span> 
    </div> 
    <div> 
     <span style="color:#333333;">（第二个参数length）</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">DatagramPacket(byte[] </span> 
    </div> 
    <div> 
     <span style="color:#333333;">buf, int offset, int length, </span> 
    </div> 
    <div> 
     <span style="color:#333333;">SocketAddress address) </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#fe2c24;">发送数据报</span> 
     <span style="color:#333333;">，发送的数据为字节 数组（第一个参数buf</span> 
     <span style="color:#333333;">）中，从</span> 
     <span style="color:#333333;">0</span> 
     <span style="color:#333333;">到指定长度</span> 
    </div> 
    <div> 
     <span style="color:#333333;">（第二个参数 length）。</span> 
     <span style="color:#333333;">address</span> 
     <span style="color:#333333;">指定目的主机的</span> 
     <span style="color:#333333;">IP</span> 
     <span style="color:#333333;">和端口号 </span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

方法：

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td style="width:132px;">方法名</td> 
   <td style="width:467px;">方法说明</td> 
  </tr> 
  <tr> 
   <td style="width:132px;"> 
    <div> 
     <span style="color:#333333;">InetAddress </span> 
    </div> 
    <div> 
     <span style="color:#333333;">getAddress() </span> 
    </div> </td> 
   <td style="width:467px;"> 
    <div> 
     <span style="color:#333333;">从接收的数据报中，获取发送端主机</span> 
     <span style="color:#333333;">IP</span> 
     <span style="color:#333333;">地址；或从发送的数据报中，获取接收端主机IP</span> 
     <span style="color:#333333;">地址 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"> 
    <div> 
     <span style="color:#333333;">int getPort() </span> 
    </div> </td> 
   <td style="width:467px;"> 
    <div> 
     <span style="color:#333333;">从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"> 
    <div> 
     <span style="color:#333333;">byte[] getData() </span> 
    </div> </td> 
   <td style="width:467px;"> 
    <div> 
     <span style="color:#333333;">获取数据报中的数据 </span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

**（2）DatagramSocket**

构造方法：

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td style="width:157px;">构造方法</td> 
   <td style="width:341px;">方法说明</td> 
  </tr> 
  <tr> 
   <td style="width:157px;"> 
    <div> 
     <span style="color:#333333;">DatagramSocket() </span> 
    </div> </td> 
   <td style="width:341px;"> 
    <div> 
     <span style="color:#333333;">创建一个</span> 
     <span style="color:#333333;">UDP</span> 
     <span style="color:#333333;">数据报套接字的</span> 
     <span style="color:#333333;">Socket</span> 
     <span style="color:#333333;">，绑定到本机任意一个随机端口 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">（一般用于客户端）</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:157px;"> 
    <div> 
     <span style="color:#333333;">DatagramSocket(int </span> 
    </div> 
    <div> 
     <span style="color:#333333;">port) </span> 
    </div> </td> 
   <td style="width:341px;"> 
    <div> 
     <span style="color:#333333;">创建一个</span> 
     <span style="color:#333333;">UDP</span> 
     <span style="color:#333333;">数据报套接字的</span> 
     <span style="color:#333333;">Socket</span> 
     <span style="color:#333333;">，绑定到本机指定的端口（一般用 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">于服务端） </span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

方法：

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td style="width:219px;">方法</td> 
   <td style="width:279px;">解析</td> 
  </tr> 
  <tr> 
   <td style="width:219px;"> 
    <div> 
     <span style="color:#333333;">void receive(DatagramPacket p)</span> 
    </div> </td> 
   <td style="width:279px;"> 
    <div> 
     <span style="color:#333333;">从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待） </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:219px;"> 
    <div> 
     <span style="color:#333333;">void send(DatagramPacketp) </span> 
    </div> </td> 
   <td style="width:279px;"> 
    <div> 
     <span style="color:#333333;">从此套接字发送数据报包（不会阻塞等待，直接发送）</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:219px;"> 
    <div> 
     <span style="color:#333333;">void close()</span> 
    </div> </td> 
   <td style="width:279px;"> 
    <div> 
     <span style="color:#333333;">关闭此数据报套接字</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

我们这以自己的地址为例子，环回IP。

**客户端代码：**

package network;
    
    import java.io.IOException;
    import java.net.*;
    import java.util.Scanner;
    
    public class UdpEchoClient {
        private DatagramSocket socket = null;
        private String serverIp;
        private int serverPort;
    
        // 服务器的 ip 和 服务器的端口.
        public UdpEchoClient(String ip, int port) throws SocketException {
            serverIp = ip;
            serverPort = port;
            // 这个 new 操作, 就不再指定端口了. 让系统自动分配一个空闲端口.
            socket = new DatagramSocket();
        }
    
        // 让这个客户端反复的从控制台读取用户输入的内容. 把这个内容构造成 UDP 请求, 发给服务器. 再读取服务器返回的 UDP 响应
        // 最终再显示在客户端的屏幕上.
        public void start() throws IOException {
            Scanner scanner = new Scanner(System.in);
            System.out.println("客户端启动!");
            while (true) {
                // 1. 从控制台读取用户输入的内容
                System.out.print("-> "); // 命令提示符, 提示用户要输入字符串.
                String request = scanner.next();
                // 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());
                // 4. 显示到屏幕上.
                System.out.println(response);
            }
        }
    
        public static void main(String[] args) throws IOException {
                                                        //服务器ip与端口
            UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
            client.start();
        }
    }

**服务器代码：**

package network;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    // UDP 的 回显服务器.
    // 客户端发的请求是啥, 服务器返回的响应就是啥.
    public class UdpEchoServer {
        private DatagramSocket socket = null;
    
        // 参数是服务器要绑定的端口
        public UdpEchoServer(int port) throws SocketException {
            socket = new DatagramSocket(port);
        }
    
        // 使用这个方法启动服务器.
        public void start() throws IOException {
            System.out.println("服务器启动!");
            while (true) {
                // 反复的, 长期的执行针对客户端请求处理的逻辑.
                // 一个服务器, 运行过程中, 要做的事情, 主要是三个核心环节.
                // 1. 读取请求, 并解析
                DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(requestPacket);
                //    这样的转字符串的前提是, 后续客户端发的数据就是一个文本的字符串.
                String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
                // 2. 根据请求, 计算出响应
                String response = process(request);
                // 3. 把响应写回给客户端
                //    此时需要告知网卡, 要发的内容是啥, 要发给谁.
                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) {
            return request;
        }
    
        public static void main(String[] args) throws IOException {
            UdpEchoServer server = new UdpEchoServer(9090);
            server.start();
        }
    }

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

## 三.TCP网络编程 ##

### 3.1TCP流套接字api ###

如果想实现TCP的通信，我们需要使用到**ServerSocket和Socket。**

**注意：TCP传输数据，是根据流操作，因此我们需要使用IO流操作**

> **（一）ServerSocket**
> 
>  *  **ServerSocket：**创建TCP服务端的Socket的API，服务器端通常用于监听指定的端口并等待客户端的连接请求

构造方法：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:243px;">构造方法</td> 
   <td style="width:255px;">方法说明</td> 
  </tr> 
  <tr> 
   <td style="width:243px;"> 
    <div> 
     <span style="color:#333333;">ServerSocket(int port) </span> 
    </div> </td> 
   <td style="width:255px;"> 
    <div> 
     <span style="color:#333333;">创建一个服务端流套接字</span> 
     <span style="color:#333333;">Socket</span> 
     <span style="color:#333333;">，并绑定到指定端口 </span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

方法：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>方法说明</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">Socket&nbsp; accept()</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端</span> 
     <span style="color:#333333;">Socket 对象，并基于该Socket</span> 
     <span style="color:#333333;">建立与客户端的连接，否则阻塞等待 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">close() </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">关闭此套接字 </span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

> **（二）Socket**
> 
>  *  **Scoket：**用于客户端，服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
> 
> 注：socket通常是一个对网络通信进行抽象的对象，通过它可以实现客户端和服务器之间的数据传输。

构造方法：

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td>构造方法</td> 
   <td>方法说明</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">Socket(String host, int port) </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">创建一个客户端流套接字</span> 
     <span style="color:#333333;">Socket</span> 
     <span style="color:#333333;">，并与对应</span> 
     <span style="color:#333333;">IP</span> 
     <span style="color:#333333;">的主机上，对应端口的进程建立连接 </span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

方法：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名</td> 
   <td>方法说明</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">InetAddress getInetAddress()</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">返回套接字所连接的地址 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">InputStream getInputStream() </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">返回此套接字的输入流 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">OutputStream getOutputStream()</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">返回此套接字的输出流 </span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

### 3.2TCP通信代码实现 ###

> TCP代码实现通信，需要先建立连接，而确认什么时候关闭，却可以分为2种----短连接和长连接！
> 
> 1.  **短连接：**每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。 
> 2.  **长连接：**不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

**长、短连接区别：**

1.  建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要 第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时 的，长连接效率更高。 
2.  主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。 
3.  两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于 客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

#### 3.2.1短连接实现代码 ####

短连接，则是一发一收，客户端发送请求，服务器接收请求，只有请求，没有回应。

**服务端：**

package org.example.tcp.demo1;
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class TcpServer {
        //服务器socket要绑定固定的端口
        private static final int PORT = 8888;
        public static void main(String[] args) throws IOException {
            // 1.创建一个服务端ServerSocket，用于收发TCP报文
            ServerSocket server = new ServerSocket(PORT);
            // 不停的等待客户端连接
            while(true) {
                System.out.println("---------------------------------");
                System.out.println("等待客户端建立TCP连接...");
                // 2.等待客户端连接，注意该方法为阻塞方法
                Socket client = server.accept();
                System.out.printf("客户端IP：%s%n", client.getInetAddress().getHostAddress());
                System.out.printf("客户端端口号：%s%n", client.getPort());
                // 5.接收客户端的数据，需要从客户端Socket中的输入流获取
                System.out.println("接收到客户端请求：");
                InputStream is = client.getInputStream();
                // 为了方便获取字符串内容，可以将以上字节流包装为字符流
                BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                String line;
                // 一直读取到流结束：TCP是基于流的数据传输，一定要客户端关闭Socket输出流才表示服
    务端接收IO输入流结束
                while ((line = br.readLine()) != null) {
                    System.out.println(line);
               }
                // 6.双方关闭连接：服务端是关闭客户端socket连接
                client.close();
           }
       }
    }

**客户端**

package org.example.tcp.demo1;
    import java.io.*;
    import java.net.Socket;
    public class TcpClient {
        //服务端IP或域名
        private static final String SERVER_HOST = "localhost";
        //服务端Socket进程的端口号
        private static final int SERVER_PORT = 8888;
        public static void main(String[] args) throws IOException {
            // 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
            Socket client = new Socket(SERVER_HOST, SERVER_PORT);
            // 4.发送TCP数据，是通过socket中的输出流进行发送
            OutputStream os = client.getOutputStream();
            // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
            // 4-1.发送数据：
            pw.println("hello world!");
            // 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
            pw.flush();
            // 7.双方关闭连接：客户端关闭socket连接
            client.close();
       }
    }

以上便是短连接，客户端不会收到回应。

#### 3.2.2长连接实现代码 ####

客户端发送请求，服务器接收请求，然后将其分析对其作出回应，传回客户端。

服务端：

import java.io.*;
    import java.net.*;
    
    
    public class TCPServer {
        public static void main(String[] args) throws IOException {
            System.out.println("服务器已启动");
    
            // 创建ServerSocket对象，监听指定端口
            ServerSocket serverSocket = new ServerSocket(8888);
    
            while (true) {
                // 等待客户端连接
                Socket socket = serverSocket.accept();
                System.out.println("已连接客户端：" + socket.getInetAddress() + ":" + socket.getPort());
    
                // 接收客户端消息
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String readLine = null;
                while ((readLine = br.readLine()) != null) {
                    System.out.println("客户端消息：" + readLine);
    
                    // 回复客户端消息
                    PrintWriter pw = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()), true);
                    pw.println("Server reply: " + readLine);
                }
            }
        }
    }

客户端：

import java.io.*;
    import java.net.*;
    
    
    public class TCPClient {
        public static void main(String[] args) throws IOException {
            // 创建Socket对象，连接指定IP和端口
            Socket socket = new Socket("localhost", 8888);
    
            // 发送消息给服务器
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()), true);
            pw.println("Hello server, I am a client.");
    
            // 接收服务器消息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String readLine = null;
            while ((readLine = br.readLine()) != null) {
                System.out.println("服务器消息：" + readLine);
            }
    
            // 关闭资源
            br.close();
            pw.close();
            socket.close();
        }
    }

## 四.总结 ##

其实，TCP的编程比UDP要难一点点，但是只要我们理解了UDP的编程实现，我们可以更方便理解TCP的编程知识。

TCP的通信代码实现，需要操作流操作，我们需要理解充分！

在学习本文之前，如果你有时间，我希望你可以查看一下：[网络的发展史、通信基础和原理][Link 3]

[TCP和UDP的由浅到深的详细讲解][TCP_UDP]

[Link 1]: https://so.csdn.net/so/search?q=%E4%B8%AA%E4%BA%BA%E4%B8%BB%E9%A1%B5&spm=1001.2101.3001.7020
[tq02_CSDN_-C_Java_Java]: https://blog.csdn.net/m0_74097410?spm=1010.2135.3001.5343
[8b2f24dd1be24d1b8dc9ed5daef97b3a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7dd43bb4cb874f589194747cb37a4408.png
[C]: http://t.csdn.cn/3A5e9
[JavaSE]: http://t.csdn.cn/TBH4P
[MySQL]: http://t.csdn.cn/2FRvG
[Link 2]: http://t.csdn.cn/LybUv
[25af2bbd964248a3ad8ffcc7130da073.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e4b20ca124c146df8f408f6533db2005.png
[ff3a312724f64b59a1cafd1923008189.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/06efee78b5d04ff884c48cce5b279447.png
[5f649cecb98b4a119025ab77bf86fe8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1d776e97ca5b4ac58f0bafb10660de26.png
[e5872a62b6fd4a6f8a13821a24ba2707.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/56f4990794b74b9ba684cef9a1dd493a.png
[29e3d642cecd4a91bd6c2ac367ab7c46.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b82f6804580d40898f3a92b426e6c4de.png
[Link 3]: http://t.csdnimg.cn/qWtkG
[TCP_UDP]: http://t.csdnimg.cn/CguHq