目录
在网络编程领域，TCP 协议是基石般的存在。今天要和大家分享的是一个有趣且富有挑战性的任务：在 48 小时内基于 TCP 实现一个简单的网络协议。这是一道来自学员反馈的笔试题，不仅考察对 TCP 协议的理解，更考验对网络编程中复杂逻辑的处理能力。
1. 笔试题剖析
1.1 题目要求
题目给定了一个基本框架，要求自定义实现一个连接对象，包含几个关键接口：send 用于发送数据，receive 用于接收数据，close 用于关闭连接，以及一个类似构造函数的接口从 TCP 连接获取自定义连接对象。除了规定接口，可自行定义其他类型、变量和函数来满足实现需求。
1.2 关键难点
- 数据标识与传输：传统 TCP 发送缺乏数据标识（key）概念，需设计合理方式在发送数据时添加标识，且接收方能够正确解析。
- 数据分块处理：send 和 receive 返回的 writer 和 reader 需支持灵活数据写入和读取，发送方可能分多次发送不同大小数据块，接收方也需能处理不同接收数据量，同时要确保接收完整数据并正确标识数据结束。
2. 协议设计思路
2.1 数据帧结构设计
为解决上述问题，设计了包含 header、数据帧和结束帧的数据帧结构。header 包含两个字段：类型字段（标识数据是 key、数据正文还是结束帧）和长度字段（表明对应数据长度）。例如，类型字段占 1 字节，长度字段若使用无符号 int64 则占 8 字节，这样 header 固定长度为 9 字节。通过先发送 header，接收方可以预先知道接下来数据类型和长度，从而正确接收和处理数据。
2.2 连接对象设计
连接对象内部包含 TCP 连接对象以及 send、receive 和 close 方法。send 方法发送数据时，先组织 header 并发送 key，接着初始化并返回 writer，之后通过 writer 继续发送数据。receive 方法接收数据时，先接收 header 并解析出 key，然后返回 reader 供业务层读取数据。close 方法则直接关闭 TCP 连接。
2.3 writer 和 reader 实现
writer 实现 write 方法时，每次写入数据前先组织 header，将 header 和数据拼接后通过 TCP 连接发送，同时在 close 方法中组织结束帧 header 发送，告知接收方数据发送完成。reader 实现相对复杂，涉及分包和粘包处理。通过 buffer 缓冲读取的数据，判断 buffer 中数据是否足够填充接收容器，若不足且 TCP 中数据未读完，则继续读取完整数据帧存入 buffer；若 buffer 数据足够则返回给业务层；若 TCP 中数据读完且 buffer 为空则返回 IO.EOF 表示数据读取结束。
3. 代码实现解析
3.1 数据类型与 header 定义
// 数据帧类型定义
const (
HeaderFrame byte = iota
DataFrame
EndFrame
)
// header结构定义
type Header struct {
FrameType byte
Length uint64
}
// header序列化方法
func (h *Header) Serialize() []byte {
buffer := make([]byte, 9)
buffer[0] = h.FrameType
binary.BigEndian.PutUint64(buffer[1:], h.Length)
return buffer
}
// header反序列化方法
func (h *Header) Deserialize(data []byte) {
h.FrameType = data[0]
h.Length = binary.BigEndian.Uint64(data[1:])
}
3.2 连接对象实现
// 自定义连接对象结构
type CustomConnection struct {
tcpConn net.TCPConn
bufferSize int
}
// send方法实现
func (c *CustomConnection) Send(key string) io.WriteCloser {
header := Header{FrameType: HeaderFrame, Length: uint64(len(key))}
serializedHeader := header.Serialize()
_, err := c.tcpConn.Write(serializedHeader)
if err!= nil {
// 错误处理
}
_, err = c.tcpConn.Write([]byte(key))
if err!= nil {
// 错误处理
}
return &CustomWriter{conn: &c.tcpConn}
}
// receive方法实现
func (c *CustomConnection) Receive() (string, io.Reader) {
headerBuffer := make([]byte, 9)
_, err := io.ReadFull(&c.tcpConn, headerBuffer)
if err!= nil {
// 错误处理
}
header := Header{}
header.Deserialize(headerBuffer)
keyBuffer := make([]byte, header.Length)
_, err = io.ReadFull(&c.tcpConn, keyBuffer)
if err!= nil {
// 错误处理
}
return string(keyBuffer), &CustomReader{conn: &c.tcpConn, buffer: make([]byte, 0), expectedLength: int(header.Length)}
}
// close方法实现
func (c *CustomConnection) Close() error {
return c.tcpConn.Close()
}
// 构造函数
func NewCustomConnection(tcpConn net.TCPConn) *CustomConnection {
return &CustomConnection{tcpConn: tcpConn, bufferSize: 1024}
}
3.3 writer 实现
// 自定义writer结构
type CustomWriter struct {
conn net.Conn
}
// write方法实现
func (w *CustomWriter) Write(data []byte) (int, error) {
header := Header{FrameType: DataFrame, Length: uint64(len(data))}
serializedHeader := header.Serialize()
combinedData := append(serializedHeader, data...)
return w.conn.Write(combinedData)
}
// close方法实现
func (w *CustomWriter) Close() error {
header := Header{FrameType: EndFrame, Length: 0}
serializedHeader := header.Serialize()
return w.conn.Write(serializedHeader)
}
3.4 reader 实现
// 自定义reader结构
type CustomReader struct {
conn net.Conn
buffer []byte
expectedLength int
readIndex int
endReached bool
}
// read方法实现
func (r *CustomReader) Read(p []byte) (int, error) {
if r.endReached {
return 0, io.EOF
}
if len(r.buffer)-r.readIndex >= len(p) {
// buffer中有足够数据
copy(p, r.buffer[r.readIndex:r.readIndex+len(p)])
r.readIndex += len(p)
return len(p), nil
} else {
// buffer中数据不足，从TCP连接读取
for len(r.buffer)-r.readIndex < len(p) {
data := make([]byte, r.expectedLength)
n, err := r.conn.Read(data)
if err!= nil {
// 错误处理
}
r.buffer = append(r.buffer, data[:n]...)
if err == io.EOF {
r.endReached = true
break
}
}
// 从buffer中复制数据到p
copy(p, r.buffer[r.readIndex:])
n := len(r.buffer) - r.readIndex
r.readIndex = len(r.buffer)
if r.endReached && n == 0 {
return 0, io.EOF
}
return n, nil
}
}
3.5 测试用例与运行结果
测试代码包含两个测试用例，分别测试数据发送和接收功能。运行测试代码后，可看到测试用例成功执行，输出结果符合预期，证明基于 TCP 实现的简单网络协议功能正常。
4. 总结与拓展
4.1 成果总结
通过 48 小时的努力，成功基于 TCP 实现了一个具备数据标识、分块处理能力的简单网络协议。这一过程不仅深入理解了 TCP 协议原理，还掌握了在复杂网络编程场景下如何设计合理的数据结构和处理逻辑。
4.2 优化方向
- 性能优化：当前实现中，数据读写和处理逻辑可能存在性能瓶颈，如频繁的内存分配和数据拷贝。可通过优化 buffer 管理、减少不必要的序列化和反序列化操作等方式提升性能。
- 错误处理增强：进一步完善错误处理机制，提供更详细准确的错误信息，以便在实际应用中更好地定位和解决问题。
希望这篇文章对大家在网络编程学习和实践中有所帮助。如果你对网络编程、TCP 协议或相关技术有更多兴趣，欢迎继续深入学习和交流。如需获取更多相关资料，如 Go 语言云原生技术资料、面试题等，请关注我们的后续分享。
标签：return,48,buffer,网络协议,TCP,header,byte,数据 From： https://blog.csdn.net/m0_57836225/article/details/144970456