Golang如何从缓冲区解析出二进制数据块

Golang如何从缓冲区解析出二进制数据块 大家好！我是Go语言的新手。关于二进制大对象（blob）的文档中有从文件读取和写入blob的示例，但我该如何直接读取缓冲区中捕获的blob呢？

    import (
    "gocloud.dev/blob"
    )
i := 0
scanner := bufio.NewScanner(conn)
for scanner.Scan() {
    // newData := scanner.Bytes()
	// bucket, er := blob.Reader(newData)
	// bucket, err := blob.OpenBucket(context.Background(), newData)
	ln := scanner.Text()    // Returns 3B blob data
	fmt.Println(ln)
}

更多关于Golang如何从缓冲区解析出二进制数据块的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于Golang如何从缓冲区解析出二进制数据块的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go语言中从缓冲区解析二进制数据块，可以通过bytes.Reader结合标准库的binary包来实现。以下是具体示例：

package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
)

// 定义二进制数据结构
type DataBlock struct {
    ID     uint32
    Length uint16
    Data   []byte
}

func parseBinaryFromBuffer(buffer []byte) (*DataBlock, error) {
    reader := bytes.NewReader(buffer)
    var block DataBlock
    
    // 按顺序解析固定长度字段
    if err := binary.Read(reader, binary.LittleEndian, &block.ID); err != nil {
        return nil, fmt.Errorf("failed to read ID: %v", err)
    }
    
    if err := binary.Read(reader, binary.LittleEndian, &block.Length); err != nil {
        return nil, fmt.Errorf("failed to read Length: %v", err)
    }
    
    // 动态读取数据部分
    block.Data = make([]byte, block.Length)
    if err := binary.Read(reader, binary.LittleEndian, &block.Data); err != nil {
        return nil, fmt.Errorf("failed to read Data: %v", err)
    }
    
    return &block, nil
}

func main() {
    // 示例二进制数据
    rawData := []byte{
        0x01, 0x00, 0x00, 0x00, // ID: 1 (小端序)
        0x03, 0x00,             // Length: 3
        0x41, 0x42, 0x43,       // Data: "ABC"
    }
    
    // 从缓冲区解析
    result, err := parseBinaryFromBuffer(rawData)
    if err != nil {
        fmt.Printf("解析失败: %v\n", err)
        return
    }
    
    fmt.Printf("ID: %d\n", result.ID)
    fmt.Printf("Length: %d\n", result.Length)
    fmt.Printf("Data: %s\n", string(result.Data))
}

对于更复杂的二进制格式，可以使用结构体标签：

type Packet struct {
    Header  uint16 `binary:"header"`
    Payload []byte `binary:"payload,length=4"`
    CRC     uint32 `binary:"crc"`
}

func parseWithStruct(buffer []byte) (*Packet, error) {
    var pkt Packet
    r := bytes.NewReader(buffer)
    
    // 使用binary.Read按定义顺序读取
    if err := binary.Read(r, binary.BigEndian, &pkt.Header); err != nil {
        return nil, err
    }
    
    pkt.Payload = make([]byte, 4)
    if err := binary.Read(r, binary.BigEndian, &pkt.Payload); err != nil {
        return nil, err
    }
    
    if err := binary.Read(r, binary.BigEndian, &pkt.CRC); err != nil {
        return nil, err
    }
    
    return &pkt, nil
}

如果处理网络数据流，可以结合bufio.Reader：

func readBinaryChunk(reader *bufio.Reader) ([]byte, error) {
    // 先读取长度字段
    lengthBytes := make([]byte, 4)
    if _, err := io.ReadFull(reader, lengthBytes); err != nil {
        return nil, err
    }
    
    length := binary.BigEndian.Uint32(lengthBytes)
    
    // 根据长度读取数据块
    data := make([]byte, length)
    if _, err := io.ReadFull(reader, data); err != nil {
        return nil, err
    }
    
    return data, nil
}

这些示例展示了如何从字节缓冲区解析二进制数据块，包括固定长度字段、动态长度字段以及网络流处理场景。

回到顶部