Go语言反射：将字节数据解组到结构体（Unmarshal）的实践指南

func Unmarshal(b []byte, t reflect.Type) (pkt interface{}, err error) {
    buf := bytes.NewBuffer(b)
    p := reflect.New(t) // p 是一个指向 t 类型新实例的 reflect.Value (Kind() == Ptr)
    v := reflect.ValueOf(p) // v 仍然是对 p 这个指针的 reflect.Value
    // ...
    for i := 0; i < t.NumField(); i++ {
        f := v.Field(i) // 尝试获取指针的第 i 个字段，这将失败或返回不可寻址的字段
        // ...
        e := binary.Read(buf, binary.BigEndian, f.Addr()) // f.Addr() 会引发 "unaddressable value" 错误
    }
    // ...
}

package main

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

// Unmarshal 将二进制数据解包并使用反射存储到结构体中。
// b: 待解组的字节数组。
// t: 目标结构体的 reflect.Type。
// 返回值: 解组后的结构体实例 (interface{}) 和可能发生的错误。
func Unmarshal(b []byte, t reflect.Type) (pkt interface{}, err error) {
    buf := bytes.NewBuffer(b)
    p := reflect.New(t) // p 是一个指向 t 类型新实例的 reflect.Value (Kind() == Ptr)
    v := p.Elem()       // 关键修正：获取 p 所指向的实际结构体值，v 是可寻址且可设置的

    // 遍历结构体的所有字段
    for i := 0; i < t.NumField(); i++ {
        fieldValue := v.Field(i) // 获取结构体字段的 reflect.Value

        // 检查字段是否可设置
        if !fieldValue.CanSet() {
            return nil, fmt.Errorf("字段 %s 不可设置", t.Field(i).Name)
        }

        // 根据字段类型进行反序列化
        switch fieldValue.Kind() {
        case reflect.String:
            // 字符串处理：通常以长度前缀 + 字节序列的形式存储
            var strLen int16
            // 读取字符串长度
            if e := binary.Read(buf, binary.BigEndian, &strLen); e != nil {
                return nil, fmt.Errorf("读取字符串长度失败: %w", e)
            }

            // 根据长度读取字符串的字节数据
            raw := make([]byte, strLen)
            if _, e := buf.Read(raw); e != nil {
                return nil, fmt.Errorf("读取字符串内容失败: %w", e)
            }

            // 将字节转换为字符串并设置到字段
            fieldValue.SetString(string(raw))

        case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
            reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
            reflect.Float32, reflect.Float64,
            reflect.Bool:
            // 对于基本数值类型，直接使用 binary.Read 写入其地址
            // 注意：fieldValue.Addr() 在 v 是可寻址时是有效的
            if e := binary.Read(buf, binary.BigEndian, fieldValue.Addr().Interface()); e != nil {
                return nil, fmt.Errorf("读取字段 %s 失败: %w", t.Field(i).Name, e)
            }
        default:
            // 暂不支持其他复杂类型，可以根据需要扩展
            return nil, fmt.Errorf("不支持的字段类型: %s (字段: %s)", fieldValue.Kind(), t.Field(i).Name)
        }
    }

    pkt = p.Interface() // 将 reflect.Value 转换回 interface{}
    return pkt, nil
}

// 示例结构体
type MyPacket struct {
    ID      uint16
    Version uint8
    Name    string
    Value   int32
    Active  bool
}

func main() {
    // 模拟一个字节数组
    // ID (uint16): 0x0001
    // Version (uint8): 0x02
    // Name (string): "GoLang" (长度6, 0x0006)
    // Value (int32): 0x0000000A (10)
    // Active (bool): true (0x01)
    data := []byte{
        0x00, 0x01, // ID: 1
        0x02,       // Version: 2
        0x00, 0x06, // Name长度: 6
        'G', 'o', 'L', 'a', 'n', 'g', // Name: "GoLang"
        0x00, 0x00, 0x00, 0x0A, // Value: 10
        0x01, // Active: true
    }

    // 调用 Unmarshal 函数
    unmarshaledPkt, err := Unmarshal(data, reflect.TypeOf(MyPacket{}))
    if err != nil {
        fmt.Printf("Unmarshal 失败: %v\n", err)
        return
    }

    // 类型断言并打印结果
    if pkt, ok := unmarshaledPkt.(*MyPacket); ok {
        fmt.Printf("解组成功！\n")
        fmt.Printf("ID: %d\n", pkt.ID)
        fmt.Printf("Version: %d\n", pkt.Version)
        fmt.Printf("Name: %s\n", pkt.Name)
        fmt.Printf("Value: %d\n", pkt.Value)
        fmt.Printf("Active: %t\n", pkt.Active)
    } else {
        fmt.Println("类型断言失败")
    }
}