Go语言Socket通信中Protobuf消息的长度前缀与字节序处理教程

package main

import (
    "bytes"
    "encoding/binary
    "fmt"
    "io"
    "log"
    "net"
    "time"
)

// 模拟发送Protobuf消息的函数
func sendMessage(conn net.Conn, message []byte) error {
    // 1. 获取消息长度
    messageLen := uint32(len(message))

    // 2. 将长度编码为字节切片。这里我们明确指定使用小端序。
    // 如果约定使用大端序，则改为 binary.BigEndian
    buf := new(bytes.Buffer)
    err := binary.Write(buf, binary.LittleEndian, messageLen) // 或 binary.BigEndian
    if err != nil {
        return fmt.Errorf("failed to write length: %w", err)
    }

    // 3. 发送长度前缀
    _, err = conn.Write(buf.Bytes())
    if err != nil {
        return fmt.Errorf("failed to send length prefix: %w", err)
    }

    // 4. 发送实际消息
    _, err = conn.Write(message)
    if err != nil {
        return fmt.Errorf("failed to send message: %w", err)
    }
    return nil
}

func main() {
    // 模拟一个简单的客户端发送逻辑
    go func() {
        conn, err := net.Dial("tcp", "localhost:8080")
        if err != nil {
            log.Printf("Client: Failed to connect: %v", err)
            return
        }
        defer conn.Close()
        log.Println("Client: Connected to server.")

        testMessage := []byte("Hello, Protobuf World!") // 实际应为Protobuf序列化后的字节
        err = sendMessage(conn, testMessage)
        if err != nil {
            log.Printf("Client: Failed to send message: %v", err)
        } else {
            log.Println("Client: Message sent successfully.")
        }
        time.Sleep(1 * time.Second) // 等待服务器处理
    }()

    // 模拟一个简单的服务器接收逻辑
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalf("Server: Failed to listen: %v", err)
    }
    defer listener.Close()
    log.Println("Server: Listening on :8080")

    conn, err := listener.Accept()
    if err != nil {
        log.Fatalf("Server: Failed to accept connection: %v", err)
    }
    defer conn.Close()
    log.Println("Server: Client connected.")

    // 接收端：读取长度前缀和消息
    var receivedLen uint32
    // 创建一个4字节的缓冲区来读取长度
    lenBuf := make([]byte, 4)
    _, err = io.ReadFull(conn, lenBuf) // 确保读取到4个字节
    if err != nil {
        log.Fatalf("Server: Failed to read length prefix: %v", err)
    }

    // 根据约定的小端序解析长度
    // 如果约定使用大端序，则改为 binary.BigEndian
    err = binary.Read(bytes.NewReader(lenBuf), binary.LittleEndian, &receivedLen) // 或 binary.BigEndian
    if err != nil {
        log.Fatalf("Server: Failed to parse length: %v", err)
    }

    log.Printf("Server: Received message length: %d bytes", receivedLen)

    message := make([]byte, receivedLen)
    _, err = io.ReadFull(conn, message) // 确保读取到完整消息
    if err != nil {
        log.Fatalf("Server: Failed to read message: %v", err)
    }

    log.Printf("Server: Received message: %s", string(message))
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "log"
    "net"
    "time"

    "google.golang.org/protobuf/proto" // 确保导入正确的protobuf包
)

// 模拟发送Protobuf消息的函数，使用Varint作为长度前缀
func sendProtobufMessage(conn net.Conn, message []byte) error {
    // 1. 获取消息长度
    messageLen := uint64(len(message))

    // 2. 将长度编码为Varint字节切片
    lenBuf := proto.EncodeVarint(messageLen)

    // 3. 发送Varint长度前缀
    _, err := conn.Write(lenBuf)
    if err != nil {
        return fmt.Errorf("failed to send Varint length prefix: %w", err)
    }

    // 4. 发送实际Protobuf消息
    _, err = conn.Write(message)
    if err != nil {
        return fmt.Errorf("failed to send Protobuf message: %w", err)
    }
    return nil
}

func main() {
    // 模拟一个简单的客户端发送逻辑
    go func() {
        conn, err := net.Dial("tcp", "localhost:8081")
        if err != nil {
            log.Printf("Client: Failed to connect: %v", err)
            return
        }
        defer conn.Close()
        log.Println("Client: Connected to server.")

        // 假设这是一个序列化后的Protobuf消息
        testMessage := []byte("This is a Protobuf message payload.")
        err = sendProtobufMessage(conn, testMessage)
        if err != nil {
            log.Printf("Client: Failed to send Protobuf message: %v", err)
        } else {
            log.Println("Client: Protobuf message sent successfully.")
        }
        time.Sleep(1 * time.Second)
    }()

    // 模拟一个简单的服务器接收逻辑
    listener, err := net.Listen("tcp", ":8081")
    if err != nil {
        log.Fatalf("Server: Failed to listen: %v", err)
    }
    defer listener.Close()
    log.Println("Server: Listening on :8081")

    conn, err := listener.Accept()
    if err != nil {
        log.Fatalf("Server: Failed to accept connection: %v", err)
    }
    defer conn.Close()
    log.Println("Server: Client connected.")

    // 接收端：读取Varint长度前缀和消息
    // proto.DecodeVarint 需要一个字节切片作为输入，通常我们会从网络读取一小部分字节
    // 直到Varint完整或达到最大Varint长度（10字节 for uint64）
    varintBuf := make([]byte, 0, 10) // 预分配最大10字节
    var receivedLen uint64
    var bytesRead int

    for {
        if len(varintBuf) >= 10 { // Varint最大为10字节
            log.Fatalf("Server: Varint length prefix exceeded max length (10 bytes)")
        }

        // 读取一个字节
        oneByte := make([]byte, 1)
        n, err := conn.Read(oneByte)
        if err != nil {
            if err == io.EOF {
                log.Println("Server: Client closed connection.")
                return
            }
            log.Fatalf("Server: Failed to read Varint byte: %v", err)
        }
        if n == 0 {
            continue // 理论上不会发生，但以防万一
        }
        varintBuf = append(varintBuf, oneByte[0])

        // 尝试解码Varint
        receivedLen, bytesRead = proto.DecodeVarint(varintBuf)
        if bytesRead > 0 { // 如果成功解码，bytesRead会大于0
            break
        }
        // 如果bytesRead == 0，表示Varint不完整，继续读取
    }

    log.Printf("Server: Received message length (Varint): %d bytes", receivedLen)

    // 此时varintBuf中可能包含了Varint长度前缀和部分消息数据。
    // 但 proto.DecodeVarint 已经处理了这个问题，它只返回了Varint部分，
    // 并且我们是通过每次读取一个字节的方式逐步构建varintBuf的。
    // 所以，现在我们已经确定了长度，可以读取剩余的消息数据。

    message := make([]byte, receivedLen)
    _, err = io.ReadFull(conn, message) // 确保读取到完整消息
    if err != nil {
        log.Fatalf("Server: Failed to read message: %v", err)
    }

    log.Printf("Server: Received Protobuf message payload: %s", string(message))
}