Go语言中高效处理TCP分片数据流

package main

import (
    "fmt"
    "net"
    "bytes" // 用于字节切片操作，如TrimPrefix
)

// handleFrame 模拟处理一个完整的数据帧
func handleFrame(frame []byte) {
    fmt.Printf("处理数据帧: %s (长度: %d)\n", string(frame), len(frame))
    // 实际应用中会进行更复杂的解析和业务处理
}

// 假设帧格式为：[长度(4字节)][数据]
// 这里简化为以换行符作为分隔符
func processBuffer(data *bytes.Buffer) {
    for {
        // 查找第一个换行符作为帧结束标记
        idx := bytes.IndexByte(data.Bytes(), '\n')
        if idx == -1 {
            // 没有找到完整帧
            break
        }

        // 提取一个完整帧 (包括换行符)
        frame := data.Next(idx + 1)
        handleFrame(bytes.TrimSuffix(frame, []byte{'\n'})) // 移除换行符再处理
    }
}

func ClientHandlerWithManualBuffer(conn net.Conn) {
    defer conn.Close()
    fmt.Printf("客户端 %s 连接\n", conn.RemoteAddr())

    // 使用bytes.Buffer作为动态缓冲区
    buffer := new(bytes.Buffer)
    readBuf := make([]byte, 4096) // 每次从连接读取的临时缓冲区

    for {
        n, err := conn.Read(readBuf)
        if err != nil {
            fmt.Println("Error reading:", err.Error())
            return
        }
        if n == 0 {
            continue // 没有数据读取
        }

        // 将读取到的数据写入动态缓冲区
        buffer.Write(readBuf[:n])

        // 尝试从动态缓冲区中解析并处理完整帧
        processBuffer(buffer)
    }
}

// 模拟TCP服务器
func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        return
    }
    defer listener.Close()
    fmt.Println("TCP服务器正在监听 :8080")

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting:", err.Error())
            continue
        }
        go ClientHandlerWithManualBuffer(conn)
    }
}

package main

import (
    "bufio"
    "fmt"
    "net"
    "time" // 用于模拟客户端发送数据
)

// handleFrame 模拟处理一个完整的数据帧
func handleFrame(frame []byte) {
    fmt.Printf("处理数据帧: %s (长度: %d)\n", string(frame), len(frame))
    // 实际应用中会进行更复杂的解析和业务处理
}

func ClientHandlerWithBufio(conn net.Conn) {
    defer conn.Close()
    fmt.Printf("客户端 %s 连接\n", conn.RemoteAddr())

    // 使用 bufio.NewReader 包装连接
    reader := bufio.NewReader(conn)

    for {
        // 示例1: 读取直到遇到特定分隔符 (如换行符 '\n')
        // ReadBytes 会读取直到分隔符，并返回包含分隔符的字节切片
        // 如果没有找到分隔符，它会读取所有可用的数据直到EOF，或者直到内部缓冲区满
        frameBytes, err := reader.ReadBytes('\n')
        if err != nil {
            // 如果是EOF，表示客户端关闭连接
            if err.Error() == "EOF" {
                fmt.Printf("客户端 %s 连接关闭\n", conn.RemoteAddr())
                return
            }
            fmt.Println("Error reading frame:", err.Error())
            return
        }

        // 移除分隔符（换行符）并处理数据帧
        // bytes.TrimSuffix(frameBytes, []byte{'\n'}) 可以用来移除末尾的换行符
        handleFrame(frameBytes[:len(frameBytes)-1]) // 假设 '\n' 是最后一个字节
    }
}

// 模拟TCP服务器
func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        return
    }
    defer listener.Close()
    fmt.Println("TCP服务器正在监听 :8080")

    go func() {
        // 模拟一个客户端连接并发送分片数据
        conn, err := net.Dial("tcp", "localhost:8080")
        if err != nil {
            fmt.Println("Client dial error:", err)
            return
        }
        defer conn.Close()

        fmt.Println("模拟客户端连接成功")

        // 发送第一个完整帧
        conn.Write([]byte("Hello, Frame 1!\n"))
        time.Sleep(100 * time.Millisecond)

        // 发送一个分片帧
        conn.Write([]byte("This is a long frame that will be sent in parts."))
        time.Sleep(100 * time.Millisecond)
        conn.Write([]byte("Part 2, and then the end of the frame.\n"))
        time.Sleep(100 * time.Millisecond)

        // 发送多个小帧
        conn.Write([]byte("Frame A\nFrame B\nFrame C\n"))
        time.Sleep(100 * time.Millisecond)

        fmt.Println("模拟客户端发送完毕")
    }()

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting:", err.Error())
            continue
        }
        go ClientHandlerWithBufio(conn)
    }
}