2024-11-30

Socket TCP 和 UDP 编程基础(Python)

网络编程是现代计算机科学的重要组成部分,而 socket 是 Python 提供的一个模块,用于实现网络通信。本文将详细介绍 TCP 和 UDP 两种通信协议的基础知识,配合 Python 代码示例和图解,让你轻松上手。


一、TCP 和 UDP 概述

1.1 TCP 协议

  • 特点:面向连接、可靠传输、适合数据量大且顺序重要的场景。
  • 应用:网页浏览、文件传输。
  • 通信模型

    • 客户端发起连接。
    • 服务端接受连接。
    • 双方建立可靠的数据传输通道。

1.2 UDP 协议

  • 特点:无连接、快速、不保证可靠传输。
  • 应用:视频直播、在线游戏。
  • 通信模型

    • 无需建立连接。
    • 数据直接发送到目标。

二、Python Socket 基础

socket 模块是 Python 提供的网络通信接口,可以实现 TCP 和 UDP 通信。

2.1 常用方法

方法说明
socket()创建一个新的 socket 对象
bind(address)绑定到指定的 IP 和端口
listen(backlog)在 TCP 中监听连接
accept()接受客户端连接
connect(address)客户端连接到服务器
send(data)发送数据
recv(buffer_size)接收数据
sendto(data, addr)向指定地址发送数据(UDP)
recvfrom(buffer_size)接收数据(UDP)
close()关闭 socket

三、TCP 编程

3.1 TCP 服务端代码

import socket

# 创建 TCP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(("127.0.0.1", 65432))  # 绑定 IP 和端口
server_socket.listen(5)  # 最大连接数

print("服务端已启动,等待连接...")
conn, addr = server_socket.accept()  # 等待客户端连接
print(f"连接来自: {addr}")

# 接收并发送数据
data = conn.recv(1024).decode("utf-8")
print(f"收到客户端消息: {data}")
conn.send("你好,客户端!".encode("utf-8"))

# 关闭连接
conn.close()
server_socket.close()

3.2 TCP 客户端代码

import socket

# 创建 TCP socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(("127.0.0.1", 65432))  # 连接服务器

# 发送数据
client_socket.send("你好,服务端!".encode("utf-8"))

# 接收数据
data = client_socket.recv(1024).decode("utf-8")
print(f"收到服务端消息: {data}")

# 关闭连接
client_socket.close()

运行结果

  • 服务端输出

    服务端已启动,等待连接...
    连接来自: ('127.0.0.1', 50000)
    收到客户端消息: 你好,服务端!
  • 客户端输出

    收到服务端消息: 你好,客户端!

TCP 通信模型图解

客户端               服务端
  |   connect()       |
  | ----------------> |
  |                   |
  |     accept()       |
  | <---------------- |
  |                   |
  |     send()         |
  | ----------------> |
  |                   |
  |     recv()         |
  | <---------------- |
  |                   |

四、UDP 编程

4.1 UDP 服务端代码

import socket

# 创建 UDP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind(("127.0.0.1", 65432))  # 绑定 IP 和端口
print("UDP 服务端已启动,等待数据...")

# 接收数据
data, addr = server_socket.recvfrom(1024)
print(f"收到来自 {addr} 的消息: {data.decode('utf-8')}")

# 发送响应
server_socket.sendto("你好,客户端!".encode("utf-8"), addr)

server_socket.close()

4.2 UDP 客户端代码

import socket

# 创建 UDP socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 发送数据
client_socket.sendto("你好,服务端!".encode("utf-8"), ("127.0.0.1", 65432))

# 接收响应
data, addr = client_socket.recvfrom(1024)
print(f"收到服务端消息: {data.decode('utf-8')}")

client_socket.close()

运行结果

  • 服务端输出

    UDP 服务端已启动,等待数据...
    收到来自 ('127.0.0.1', 50000) 的消息: 你好,服务端!
  • 客户端输出

    收到服务端消息: 你好,客户端!

UDP 通信模型图解

客户端               服务端
  |   sendto()        |
  | ----------------> |
  |                   |
  |     recvfrom()     |
  | <---------------- |

五、TCP 与 UDP 的区别

特性TCPUDP
是否连接面向连接无连接
数据可靠性高,保证数据按顺序到达不可靠,不保证顺序
速度较慢,需建立连接和确认快,无需连接
应用场景文件传输、网页浏览视频流、在线游戏

六、综合练习:多人聊天室

服务端代码

import socket
import threading

# 创建服务端
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(("127.0.0.1", 65432))
server_socket.listen(5)
clients = []

def handle_client(conn, addr):
    print(f"新客户端加入: {addr}")
    while True:
        try:
            data = conn.recv(1024).decode("utf-8")
            if not data:
                break
            print(f"{addr}: {data}")
            for client in clients:
                if client != conn:
                    client.send(f"{addr}: {data}".encode("utf-8"))
        except:
            break
    conn.close()
    clients.remove(conn)

print("聊天室启动中...")
while True:
    conn, addr = server_socket.accept()
    clients.append(conn)
    threading.Thread(target=handle_client, args=(conn, addr)).start()

客户端代码

import socket
import threading

def receive_messages(client_socket):
    while True:
        try:
            message = client_socket.recv(1024).decode("utf-8")
            print(message)
        except:
            print("连接已关闭")
            break

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(("127.0.0.1", 65432))

threading.Thread(target=receive_messages, args=(client_socket,)).start()

print("加入聊天室!输入消息开始聊天...")
while True:
    msg = input()
    client_socket.send(msg.encode("utf-8"))

七、总结

通过本文,你应该已经掌握了 Python 中基于 socket 模块进行 TCP 和 UDP 编程的基本方法。无论是构建简单的客户端-服务端模型,还是开发复杂的网络应用,都可以从这些基础知识入手。希望你通过练习能够熟练运用这些技术!

2024-09-04



#include <QCoreApplication>
#include <QUdpSocket>
#include <QHostAddress>
#include <QDebug>
 
int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
 
    QUdpSocket udpSocket;
    udpSocket.writeDatagram("Hello, UDP!", QHostAddress::LocalHost, 12345);
 
    while (true) {
        char buffer[1024];
        QHostAddress sender;
        quint16 senderPort;
        // 等待数据报的到来
        if (udpSocket.waitForReadyRead(3000)) {
            // 读取数据报
            while (udpSocket.hasPendingDatagrams()) {
                qint64 size = udpSocket.pendingDatagramSize();
                if (size > 1024) {
                    continue;
                }
                udpSocket.readDatagram(buffer, size, &sender, &senderPort);
                qDebug() << "Received:" << buffer << "from" << sender << senderPort;
            }
        } else {
            qDebug() << "Timeout waiting for UDP datagram.";
            break;
        }
    }
 
    return a.exec();
}

这段代码展示了如何使用Qt的QUdpSocket类来发送和接收UDP数据报。首先,我们创建了一个QUdpSocket对象并使用writeDatagram函数发送了一个数据报。然后,我们使用waitForReadyRead函数等待接收数据报,并使用readDatagram函数读取数据报内容。这里使用了一个循环来处理可能存在的多个数据报,并对每个数据报进行了处理。如果在指定时间内没有数据报到来,我们会打印一条超时信息并退出循环。

2024-08-27

以下是一个简单的UDP回显服务器和客户端的示例代码。服务器监听在端口9999上,并将接收到的任何消息发送回客户端。客户端连接到服务器并发送消息,然后接收回显。

服务器端 (server.c):




#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
 
#define BUF_SIZE 1024
#define PORT 9999
 
int main() {
    int server_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (server_fd < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
 
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    int bind_ret = bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (bind_ret < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    char buffer[BUF_SIZE];
    int read_len;
 
    while (1) {
        memset(buffer, 0, BUF_SIZE);
        read_len = recvfrom(server_fd, buffer, BUF_SIZE, 0, (struct sockaddr *)&client_addr, &client_addr_len);
        if (read_len < 0) {
            perror("recvfrom failed");
            exit(EXIT_FAILURE);
        }
        printf("Received message: %s\n", buffer);
 
        int send_ret = sendto(server_fd, buffer, read_len, 0, (struct sockaddr *)&client_addr, client_addr_len);
        if (send_ret < 0) {
            perror("sendto failed");
            exit(EXIT_FAILURE);
        }
    }
 
    close(server_fd);
    return 0;
}

客户端 (client.c):




#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
 
#define BUF_SIZE 1024
#define PORT 9999
#define SERVER_IP "127.0.0.1"
 
int main() {
    int client_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (client_fd < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
 
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);
 
    char buffer[BUF_SIZE];
    printf("Enter message: ");
    fgets(buffer, BUF_SIZE, stdin);
 
    int send_ret = sendto(client_fd, buffer, strlen(buffer),
2024-08-26



import java.net.*;
 
public class UdpEchoClient {
    public static void main(String[] args) {
        try {
            // 创建数据报套接字连接本地端口3721
            DatagramSocket socket = new DatagramSocket();
 
            // 确定服务器地址和端口
            InetAddress serverAddress = InetAddress.getByName("127.0.0.1");
            int serverPort = 3721;
 
            // 创建数据包,准备发送的数据
            String message = "Hello, UDP server!";
            byte[] data = message.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(data, data.length, serverAddress, serverPort);
 
            // 发送数据报
            socket.send(sendPacket);
 
            // 准备接收返回的数据
            byte[] buffer = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
 
            // 接收服务器返回的数据报
            socket.receive(receivePacket);
 
            // 输出服务器返回的数据
            String receivedMessage = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Received message: " + receivedMessage);
 
            // 关闭数据报套接字
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这段代码展示了如何使用Java的DatagramSocketDatagramPacket类来实现UDP协议的客户端通信。代码创建了一个数据报套接字,准备了发送和接收数据的数据包,并且展示了如何发送数据到服务器和接收服务器的响应。最后,关闭了数据报套接字,完成整个通信过程。

2024-08-26

在Java中,网络编程主要涉及到以下三个要素:

  1. 网络协议:例如TCP/IP、UDP等。
  2. 本地Socket:是网络通信过程中的一个端点。
  3. 远程Socket:是网络通信过程中的另一个端点。

软件架构分为C/S架构和B/S架构:

  1. C/S架构:即Client/Server(客户端/服务器)架构,此种架构下,用户界面在客户端,所有的逻辑处理和数据存取都在服务器端进行。
  2. B/S架构:即Browser/Server(浏览器/服务器)架构,此种架构下,用户界面通过浏览器进行访问,数据的处理和存储在服务器端进行。

UDP(用户数据报协议)是一个无连接的协议,适用于对网络通信质量要求不高,但对传输速度要求高的场合。

以下是一个UDP发送数据的Java代码示例:




import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
 
public class UDPSend {
    public static void main(String[] args) throws Exception {
        // 1. 创建数据包(包含要发送的数据)
        byte[] data = "Hello, UDP".getBytes();
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("localhost"), 10000);
 
        // 2. 创建DatagramSocket对象
        DatagramSocket socket = new DatagramSocket();
 
        // 3. 发送数据
        socket.send(packet);
 
        // 4. 关闭socket
        socket.close();
    }
}

以下是一个UDP接收数据的Java代码示例:




import java.net.DatagramPacket;
import java.net.DatagramSocket;
 
public class UDPReceive {
    public static void main(String[] args) throws Exception {
        // 1. 创建DatagramSocket,指定端口号
        DatagramSocket socket = new DatagramSocket(10000);
 
        // 2. 创建数据包,用于存储接收的数据
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
 
        // 3. 接收数据
        socket.receive(packet);
 
        // 4. 处理数据
        String data = new String(packet.getData(), 0, packet.getLength());
        System.out.println("Received data: " + data);
 
        // 5. 关闭socket
        socket.close();
    }
}

以上代码实现了UDP协议的发送和接收数据的基本流程。在实际应用中,可能需要处理网络异常和并发问题。

2024-08-23



#include <stdio.h>
#include <stdlib.com>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define BUF_SIZE 30
 
int main(int argc, char *argv[]) {
    int sockfd;
    struct sockaddr_in servaddr;
    char buf[BUF_SIZE];
    int ret;
 
    if (argc != 3) {
        printf("usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }
 
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket creation failed");
        exit(1);
    }
 
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(atoi(argv[2]));
    inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
 
    while (1) {
        printf("Enter message(q to quit): ");
        fgets(buf, BUF_SIZE, stdin);
        if (!strncmp(buf, "q", 1)) {
            break;
        }
 
        sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr*)&servaddr, sizeof(servaddr));
 
        ret = recvfrom(sockfd, buf, BUF_SIZE-1, 0, NULL, NULL);
        if (ret == -1) {
            perror("recvfrom error");
            exit(1);
        }
        buf[ret] = '\0';
        printf("Received message: %s\n", buf);
    }
 
    close(sockfd);
    return 0;
}

这段代码展示了如何使用UDP协议在Linux环境下创建一个简单的网络客户端。它首先检查命令行参数是否正确,然后创建一个UDP套接字。用户可以输入消息并发送到服务器,然后等待接收回应。如果输入“q”,客户端将退出。这个例子教导如何使用UDP套接字发送和接收数据,是学习网络编程的基础。

2024-08-19

在标准的IPv4网络中,TCP和UDP数据包的最大有效负载大小(payload size)通常被称为最大传输单元(Maximum Transmission Unit, MTU)。对于以太网,MTU默认值为1500字节。这意味着TCP数据包(包括TCP头部)最大可以为1500字节,而UDP数据包(包括UDP头部)最大可以为1472字节(1500字节的MTU减去20字节的UDP头部和8字节的IP头部)。

但是,在实际网络传输中,可能会遇到路径MTU发现(Path MTU Discovery)的情况,这时候数据包会被分片(fragmentation)。为了避免这种情况,通常建议设置TCP的MSS(Maximum Segment Size)来限制每个分片的大小,从而减少分片和提高网络效率。

在Go语言中,可以通过设置网络接口来改变TCP的MSS值,但是对于UDP数据包大小,你需要确保你的应用逻辑可以处理UDP数据包的分片。

以下是Go语言中设置TCP MSS的示例代码:




conn, err := net.Dial("tcp", "example.com:80")
if err != nil {
    log.Fatal(err)
}
defer conn.Close()
 
tcpConn := conn.(*net.TCPConn)
 
// 获取默认的TCP头部选项
err = tcpConn.SetWriteBuffer(1024 * 1024) // 设置为1MB的TCP缓冲区
if err != nil {
    log.Fatal(err)
}
 
// 设置MSS为1460字节(1500字节MTU减去20字节TCP头部和20字节IP头部)
err = tcpConn.SetMSS(1460)
if err != nil {
    log.Fatal(err)
}
 
// 此处可以正常发送数据

对于UDP数据包,Go语言没有提供直接设置UDP数据包大小的方法,因为UDP数据包大小受限于MTU。但是,你可以在发送UDP数据前,检查数据大小并确保它不会超过你期望的MTU大小。例如,如果你期望的MTU是1500字节,你可以这样做:




udpConn, err := net.ListenUDP("udp", &net.UDPAddr{
    IP:   net.ParseIP("127.0.0.1"),
    Port: 12345,
})
if err != nil {
    log.Fatal(err)
}
defer udpConn.Close()
 
maxUDPPayloadSize := 1500 - (20 + 8) // 1500 MTU减去20字节UDP头部和8字节IP头部
 
buffer := make([]byte, maxUDPPayloadSize)
// 填充buffer数据
 
n, addr, err := udpConn.WriteMsgUDP(buffer, nil, nil)
if err != nil {
    log.Fatal(err)
}
 
fmt.Printf("Wrote %d bytes to %v\n", n, addr)

在上面的代码中,我们计算了最大UDP有效负载大小,并在发送前确保数据包大小不超过这个值。如果你需要发送大于1500字节的数据,你需要分片你的数据并在接收端重新组合它们,这通常是通过UDP协议栈自动完成的,除非你的网络环境不允许路

2024-08-19



import java.net.*;
 
public class UdpEchoClient {
    public static void main(String[] args) {
        try {
            // 确定服务器地址和端口
            InetAddress serverAddress = InetAddress.getByName("127.0.0.1");
            int port = 7;
            // 创建数据报套接字
            DatagramSocket socket = new DatagramSocket();
 
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                if (inputLine.equals("exit")) {
                    break;
                }
                // 将输入的文本转换为字节
                byte[] bytes = inputLine.getBytes();
                // 创建数据报,包含输入的文本
                DatagramPacket outgoing = new DatagramPacket(bytes, bytes.length, serverAddress, port);
                // 发送数据报
                socket.send(outgoing);
 
                // 创建用于接收响应的数据报
                byte[] inBuffer = new byte[100];
                DatagramPacket incoming = new DatagramPacket(inBuffer, inBuffer.length);
                // 接收服务器的响应
                socket.receive(incoming);
                // 输出服务器的响应
                System.out.println("Received: " + new String(incoming.getData(), 0, incoming.getLength()));
            }
            // 关闭数据报套接字
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这段代码展示了如何使用Java的DatagramSocketDatagramPacket类来实现一个简单的UDP回显客户端。客户端从标准输入读取文本,将其发送到本地主机的7号端口,并接收服务器的响应。当输入"exit"时,客户端关闭套接字并退出。这个例子是网络编程入门的一个很好的起点。

2024-08-19

下面是一个简单的UDP聊天程序的示例代码,实现了客户端和服务器端的基本功能。

服务器端 (server.c):




#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define BUF_SIZE 1024
#define SERVER_PORT 8888
 
int main() {
    struct sockaddr_in server_addr, client_addr;
    socklen_t addr_len;
    int sock_fd;
    char buf[BUF_SIZE];
    int i, res;
 
    // 创建socket
    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 
    // 定义服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERVER_PORT);
 
    // 绑定socket到地址
    bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
 
    printf("Server is running on port %d, waiting for messages...\n", SERVER_PORT);
 
    while (1) {
        addr_len = sizeof(client_addr);
        // 接收数据
        res = recvfrom(sock_fd, buf, BUF_SIZE, 0, (struct sockaddr *)&client_addr, &addr_len);
        if (res == -1) {
            perror("recvfrom error");
            continue;
        }
        buf[res] = '\0';
        printf("Received message: %s\n", buf);
 
        // 发送数据回客户端
        strcat(buf, " (from server)");
        res = sendto(sock_fd, buf, strlen(buf), 0, (struct sockaddr *)&client_addr, addr_len);
        if (res == -1) {
            perror("sendto error");
        }
    }
 
    close(sock_fd);
    return 0;
}

客户端 (client.c):




#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define BUF_SIZE 1024
#define SERVER_PORT 8888
#define SERVER_IP "127.0.0.1"
 
int main() {
    struct sockaddr_in server_addr;
    int sock_fd;
    char buf[BUF_SIZE];
    int res;
 
    // 创建socket
    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 
    // 定义服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
    server_addr.sin_port = htons(SERVER_PORT);
 
    printf("Chat client is running, enter messages and hit enter to send.\n");
 
    while (fgets(buf, BUF_SIZE, stdin) != NULL) {
        // 发送数据到服务器
        res = sendto(sock_fd, buf, strlen(buf), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
        if (res == -1) {
            perror("sendto error");
            continue;
        }
 
        // 接收来
2024-08-19



package main
 
import (
    "fmt"
    "net"
    "os"
)
 
func main() {
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s host:port\n", os.Args[0])
        os.Exit(1)
    }
    service := os.Args[1]
 
    udpAddr, err := net.ResolveUDPAddr("udp", service)
    checkError(err)
 
    conn, err := net.DialUDP("udp", nil, udpAddr)
    checkError(err)
 
    _, err = conn.Write([]byte("Hello, world!\n"))
    checkError(err)
 
    var buf [512]byte
    n, err := conn.Read(buf[0:])
    checkError(err)
 
    fmt.Println("Received:", string(buf[0:n]))
    os.Exit(0)
}
 
func checkError(err error) {
    if err != nil {
        fmt.Fprintf(os.Stderr, "Fatal error: %s\n", err.Error())
        os.Exit(1)
    }
}

这段代码使用Go语言实现了一个简单的UDP客户端。它首先检查命令行参数的数量是否正确。然后,它将命令行参数(应该是服务器的地址和端口)解析为UDP地址。接下来,它创建一个UDP连接,向服务器发送一条"Hello, world!"消息,并从服务器读取响应。如果在过程中发生错误,它会打印出错误信息并退出程序。这个例子展示了如何使用Go语言进行UDP网络编程的基本步骤。