Golang通過包長協定處理TCP粘包的問題解決

/*
    檔名：client.go
    client使用者端的範例程式碼（未處理粘包問題）
    通過無限迴圈無時間間隔傳送資料給server伺服器
    server將會不間斷的出現TCP粘包問題
*/
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
        }
        // 這裡通過限制傳送頻率和時間間隔來解決TCP粘包
        // 雖然能夠實現，但是頻率被限制，效率也會被限制
        // time.Sleep(time.Second * 1)
    }
}

/*
    檔名：server.go
    server伺服器端的範例程式碼（未處理粘包問題）
    伺服器端接收到資料後立即列印
    此時將會不間斷的出現TCP粘包問題
*/
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)
            fmt.Println("Read N:", n)
            return
        }
        fmt.Println(string(buf))
    }
}

/*
    檔名：client.go
    使用包長協定，封裝TCP包並回圈傳送給server伺服器端
*/
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!"
        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)
            fmt.Println("Error N:", n)
            return
        }
        // time.Sleep(time.Second * 1)
    }
}

/*
    檔名：server.go
    使用包長協定，處理接收到的封包資料
    收到的封包資料，可能存在幾種情況：
    1、封包總長度不足2位元組（這種情況不能完整獲取包頭），快取起來與下次獲取的資料拼接
    2、封包總長度剛好2位元組，資料長度資訊讀出來是0，這種情況可以正常處理並清空快取
    3、封包總長度大於2位元組，資料長度資訊大於封包資料實際長度，表示封包不完整，需要等到下一次讀取再拼接起來
    4、封包總長度大於2位元組，資料長度資訊等於封包資料實際長度，這種情況（理想情況）可以正常處理並清空快取
    5、封包總長度大於2位元組，資料長度資訊小於封包實際長度，表示封包發生TCP粘包了，讀取實際資料後，將剩餘部分快取起來等待下次拼接
    PS：這裡只總結出了這幾種情況，其他未發現的情況還需另外處理
*/
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 := []byte{}
    for {
        buf := make([]byte, 1024)
        // fmt.Println("len:", len(buf), " cap:", cap(buf))
        n, err := conn.Read(buf)
        if err != nil {
            if e, ok := err.(*net.OpError); ok {
                fmt.Println(e.Source, e.Addr, e.Net, e.Op, e.Err)
                if e.Timeout() {
                    fmt.Println("Timeout Error")
                }
            }
            fmt.Println("Read Error:", err)
            fmt.Println("Read N:", n)
            return
        }
        if n == 0 {
            fmt.Println("Read N:", n)
            return
        }
        tmp = append(tmp, buf[:n]...)
        length := len(tmp)
        if length < 2 {
            continue
        }
        if length >= 2 {
            head := make([]byte, 2)
            copy(head, tmp[:2])
            dataLength := binary.BigEndian.Uint16(head)
            data := make([]byte, dataLength)
            copy(data, tmp[2:dataLength+2])
            fmt.Println(string(data)) // 得到資料
            if uint16(length) == 2+dataLength {
                tmp = []byte{}
            } else if uint16(length) > 2+dataLength {
                tmp = tmp[dataLength+2:]
            }
        }
        // fmt.Println(string(buf))
    }
}