1. 自定义固定长度协议设计
在网络通信中，定义清晰的数据包协议是实现客户端与服务器有效交互的基础。本示例采用一个简单的固定长度协议，其结构定义如下：
type packet struct {
// 字段名必须大写，以便 encoding/binary 包进行编解码。
// 此外，建议使用明确指定大小的类型，如 int32 而非 int，以确保跨平台一致性。
Type int32
Id int32
// Data 字段必须是固定大小的数组 ([100]byte)，而不是切片 ([]byte)，
// 这样 encoding/binary 才能直接将其作为结构体的一部分进行处理。
Data [100]byte
}- Type (int32): 用于标识数据包的类型，例如请求、响应、心跳等。
- Id (int32): 数据包的唯一标识符，可用于匹配请求与响应。
- Data ([100]byte): 承载实际数据内容的字节数组。这里为了简化示例，设定为固定100字节长度。
设计要点：
- 字段可见性： encoding/binary包只能对结构体中可导出的（即首字母大写的）字段进行编解码操作。
- 明确类型： 使用 int32 而非 Go 语言原生的 int 类型，是为了确保在不同操作系统和CPU架构下，数据类型所占用的字节数保持一致，避免因 int 长度不确定（32位或64位）导致的兼容性问题。
- 固定大小数组： encoding/binary在处理结构体时，会将固定大小的数组直接作为连续字节流的一部分进行编解码。如果使用切片（[]byte），则需要额外处理其长度信息，通常是在协议中增加一个表示切片长度的字段，并分步读取。
2. 服务端实现
Go语言的net包提供了强大的TCP网络编程能力。服务端的主要职责是监听特定端口，接受客户端连接，并处理收到的数据包，然后发送响应。
package main
import (
"encoding/binary"
"fmt"
"net"
)
// packet 结构体定义同上
type packet struct {
Type int32
Id int32
Data [100]byte
}
func main() {
// 在端口 2000 上设置 TCP 监听器
l, err := net.Listen("tcp", ":2000")
if err != nil {
// 在生产环境中，应避免使用 panic，而应进行更健壮的错误处理，例如日志记录并退出。
panic(err.Error())
}
defer l.Close() // 确保监听器在程序退出时关闭，释放端口资源
fmt.Println("Server listening on :2000")
for {
// 阻塞等待并接受新的客户端连接
conn, err := l.Accept()
if err != nil {
fmt.Printf("Error accepting connection: %s\n", err.Error())
continue // 继续监听下一个连接
}
// 当前示例仅处理单个连接。在实际应用中，为了支持并发，应为每个连接启动一个 goroutine
fmt.Printf("Accepted connection from %s\n", conn.RemoteAddr())
handleClient(conn) // 调用函数处理客户端连接
}
}
// handleClient 处理单个客户端连接的通信逻辑
func handleClient(conn net.Conn) {
defer conn.Close() // 确保连接在处理完毕后关闭，释放资源
// 等待接收客户端发送的数据包
var msg packet
// 使用 binary.Read 从连接中读取数据并反序列化到 msg 结构体。
// binary.BigEndian 指定字节序为大端序，客户端和服务器必须保持一致。
err := binary.Read(conn, binary.BigEndian, &msg)
if err != nil {
fmt.Printf("Error reading packet from %s: %s\n", conn.RemoteAddr(), err.Error())
return
}
// 打印收到的数据内容。Data 是字节数组，需要转换为字符串进行可读性输出。
// 注意：msg.Data[:] 转换为切片后打印，可以避免打印整个100字节数组的空余部分。
fmt.Printf("Received a packet from %s (Type: %d, Id: %d): %s\n", conn.RemoteAddr(), msg.Type, msg.Id, msg.Data[:])
// 准备并发送响应数据包
response := packet{Type: 1, Id: 1}
// 将字符串内容复制到 Data 字节数组中。
copy(response.Data[:], "Hello, client from server!")
// 使用 binary.Write 将 response 结构体序列化并写入连接。
err = binary.Write(conn, binary.BigEndian, &response)
if err != nil {
fmt.Printf("Error writing response to %s: %s\n", conn.RemoteAddr(), err.Error())
return
}
fmt.Printf("Sent response to %s.\n", conn.RemoteAddr())
}服务端流程说明：
- 监听： net.Listen("tcp", ":2000") 在本地地址的2000端口上创建一个TCP监听器。
- 接受连接： l.Accept() 阻塞等待并接受新的客户端连接。每当有客户端连接时，它返回一个 net.Conn 接口，代表该连接。
- 处理连接： handleClient 函数负责处理单个客户端的通信逻辑。
- 读取数据： binary.Read(conn, binary.BigEndian, &msg) 从连接中读取固定长度的字节流，并根据 packet 结构体的定义将其反序列化。binary.BigEndian 指定了字节序，这在跨平台通信中至关重要，客户端和服务器必须使用相同的字节序。
- 发送响应： 构造一个 packet 结构体作为响应，使用 copy 将字符串数据填充到 Data 字段中，然后通过 binary.Write(conn, binary.BigEndian, &response) 将结构体序列化并发送回客户端。
- 资源清理： defer conn.Close() 确保每个连接在处理完毕后都会被正确关闭，释放系统资源。defer l.Close() 确保监听器在程序退出时关闭。
3. 客户端实现
客户端负责主动发起连接到服务器，发送数据包，并接收服务器的响应。
立即学习“go语言免费学习笔记（深入）”；
package main
import (
"encoding/binary"
"fmt"
"net"
)
// packet 结构体定义同上
type packet struct {
Type int32
Id int32
Data [100]byte
}
func main() {
// 连接到本地主机的 2000 端口
conn, err := net.Dial("tcp", "localhost:2000")
if err != nil {
panic(err.Error()) // 生产环境中应避免使用 panic
}
defer conn.Close() // 确保连接在程序退出时关闭
fmt.Println("Connected to server.")
// 准备并发送一个数据包
msg := packet{Type: 0, Id: 0}
copy(msg.Data[:], "Hello, server from client!")
err = binary.Write(conn, binary.BigEndian, &msg)
if err != nil {
fmt.Printf("Error writing packet: %s\n", err.Error())
return
}
fmt.Println("Sent packet to server.")
// 接收服务器的响应
var response packet
err = binary.Read(conn, binary.BigEndian, &response)
if err != nil {
fmt.Printf("Error reading response: %s\n", err.Error())
return
}
// 打印收到的响应内容
fmt.Printf("Received response (Type: %d, Id: %d): %s\n", response.Type, response.Id, response.Data[:])
}客户端流程说明：
- 建立连接： net.Dial("tcp", "localhost:2000") 尝试与指定地址和端口的TCP服务器建立连接。
- 发送数据：
