Golang解决TCP粘包问题：通过自定义包长协议处理数据拆分

/*
    client.go - 未处理粘包的客户端
    通过无限循环无间隔发送数据，诱发粘包
*/
package main
import (
    "fmt"
    "net"
)
func main() {
    conn, err := net.Dial("tcp", ":9000")
    if err != nil {
        return
    }
    defer conn.Close()
    for {
        s := "Hello, Server!"
        n, err := conn.Write([]byte(s))
        if err != nil {
            fmt.Println("Error:", err)
            fmt.Println("Error N:", n)
            return
        }
        // 增加时间间隔可缓解但无法根除粘包
        // time.Sleep(time.Second * 1)
    }
}

/*
    server.go - 未处理粘包的服务端
    直接打印接收到的字节流，导致多包混读
*/
package main
import (
    "fmt"
    "net"
)
func main() {
    ln, err := net.Listen("tcp", ":9000")
    if err != nil {
        return
    }
    for {
        conn, err := ln.Accept()
        if err != nil {
            continue
        }
        go handleConnection(conn)
    }
}
func handleConnection(conn net.Conn) {
    defer conn.Close()
    tmp := []byte{}
    for {
        buf := make([]byte, 1024)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Read Error:", err)
            return
        }
        fmt.Println(string(buf))
    }
}

/*
    client.go - 使用包长协议的客户端
    先写入2字节长度头，再写入实际数据
*/
package main
import (
    "encoding/binary"
    "fmt"
    "net"
)
func main() {
    conn, err := net.Dial("tcp", ":9000")
    if err != nil {
        return
    }
    defer conn.Close()
    for {
        s := "Hello, Server!"
        // 计算总长度：2字节包头 + 字符串长度
        sbytes := make([]byte, 2+len(s))
        // 将字符串长度转为大端序填入包头
        binary.BigEndian.PutUint16(sbytes, uint16(len(s)))
        // 拷贝数据到包头之后
        copy(sbytes[2:], []byte(s))
        
        n, err := conn.Write(sbytes)
        if err != nil {
            fmt.Println("Error:", err)
            return
        }
        // time.Sleep(time.Second * 1)
    }
}

/*
    server.go - 使用包长协议处理接收到的封包
*/
package main
import (
    "encoding/binary"
    "fmt"
    "net"
)
func main() {
    ln, err := net.Listen("tcp", ":9000")
    if err != nil {
        return
    }
    for {
        conn, err := ln.Accept()
        if err != nil {
            continue
        }
        go handleConnection(conn)
    }
}
func handleConnection(conn net.Conn) {
    defer conn.Close()
    // tmp 用于缓存未完整读取的数据块
    tmp := []byte{}
    for {
        buf := make([]byte, 1024)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Read Error:", err)
            return
        }
        if n == 0 {
            fmt.Println("Connection closed by peer")
            return
        }
        // 追加新接收到的数据到临时缓冲区
        tmp = append(tmp, buf[:n]...)
        length := len(tmp)
        
        // 1. 若缓冲区数据不足2字节，说明连包头都没读完，继续等待
        if length < 2 {
            continue
        }
        
        // 2. 解析包头，获取预期数据长度
        head := make([]byte, 2)
        copy(head, tmp[:2])
        dataLength := binary.BigEndian.Uint16(head)
        
        // 3. 处理业务数据：从临时缓冲区的第3字节开始提取
        if length >= int(dataLength)+2 {
            // 提取出当前完整的包数据
            currentData := tmp[2 : dataLength+2]
            fmt.Println("Got Data:", string(currentData))
            
            // 检查剩余未消费数据
            totalConsumed := int(dataLength) + 2
            if length > totalConsumed {
                // 发生了粘包，剩余部分保留在tmp开头供下次循环解析
                remainingData := make([]byte, length-totalConsumed)
                copy(remainingData, tmp[totalConsumed:])
                tmp = remainingData
            } else {
                // 数据刚好，清空临时缓冲区
                tmp = []byte{}
            }
        }
        // 若缓冲区长度 >= 2 但不足以取出完整 payload (length < 2+dataLength)
        // 则continue进入下一次Read，等待数据凑齐
    }
}