Go 反射实战：正确地将字节数据反序列化到结构体字段

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

// Unmarshal 尝试将二进制数据反序列化到结构体中。
// 注意：此为问题代码，存在地址性问题。
func UnmarshalProblematic(b []byte, t reflect.Type) (pkt interface{}, err error) {
    buf := bytes.NewBuffer(b)
    p := reflect.New(t) // p 是一个 reflect.Value，代表 *T (指向类型t的指针)
    v := reflect.ValueOf(p) // v 再次包装了 p，它现在是 reflect.Value(reflect.Value(*T))

    for i := 0; i < t.NumField(); i++ {
        f := v.Field(i) // 这里是问题所在，v.Field(i) 尝试访问 p (一个 reflect.Value) 的字段

        switch f.Kind() {
        case reflect.String:
            var l int16
            if e := binary.Read(buf, binary.BigEndian, &l); e != nil {
                err = e
                return
            }
            raw := make([]byte, l)
            if _, e := buf.Read(raw); e != nil {
                err = e
                return
            }
            f.SetString(bytes.NewBuffer(raw).String())
        default:
            // 尝试获取字段 f 的地址，但 f 是不可寻址的
            if e := binary.Read(buf, binary.BigEndian, f.Addr().Interface()); e != nil {
                err = e
                return
            }
        }
    }

    pkt = p.Interface() // 返回指针类型
    return
}

p := reflect.New(t)   // p 是一个 reflect.Value，代表 *T
v := p.Elem()         // v 是一个 reflect.Value，代表 T (结构体本身)

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

// Unmarshal 将二进制数据反序列化到结构体中。
// 参数 b: 待反序列化的字节切片。
// 参数 t: 目标结构体的 reflect.Type。
// 返回 pkt: 反序列化后的结构体实例（作为 interface{} 返回）。
// 返回 err: 如果反序列化过程中发生错误，则返回错误。
func Unmarshal(b []byte, t reflect.Type) (pkt interface{}, err error) {
    // 确保 t 是一个结构体类型
    if t.Kind() != reflect.Struct {
        return nil, fmt.Errorf("Unmarshal expects a struct type, but got %v", t.Kind())
    }

    buf := bytes.NewBuffer(b)
    // reflect.New(t) 创建一个指向类型 t 的零值的指针
    // 例如，如果 t 是 MyStruct，那么 p 是 reflect.Value(*MyStruct)
    p := reflect.New(t)

    // p.Elem() 获取 p 所指向的实际值
    // 例如，如果 p 是 reflect.Value(*MyStruct)，那么 v 是 reflect.Value(MyStruct)
    // 此时 v 是一个可寻址的 reflect.Value，代表了实际的结构体实例
    v := p.Elem()

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

        // 检查字段是否可设置 (Set)，私有字段不可设置
        if !fieldValue.CanSet() {
            return nil, fmt.Errorf("field %s is not settable", fieldType.Name)
        }

        switch fieldValue.Kind() {
        case reflect.String:
            // 字符串处理：先读取长度 (int16)，再根据长度读取字节数据
            var strLen int16
            if e := binary.Read(buf, binary.BigEndian, &strLen); e != nil {
                return nil, fmt.Errorf("failed to read string length for field %s: %w", fieldType.Name, e)
            }

            if strLen < 0 {
                return nil, fmt.Errorf("invalid string length %d for field %s", strLen, fieldType.Name)
            }

            rawStringBytes := make([]byte, strLen)
            if _, e := buf.Read(rawStringBytes); e != nil {
                return nil, fmt.Errorf("failed to read string bytes for field %s: %w", fieldType.Name, e)
            }
            fieldValue.SetString(string(rawStringBytes)) // 将字节转换为字符串并设置
        // 可以添加其他复杂类型的处理，例如切片、数组等
        default:
            // 对于基本类型（如 int, float, bool 等），直接使用 binary.Read
            // fieldValue.Addr().Interface() 返回字段地址的 interface{} 表示
            if e := binary.Read(buf, binary.BigEndian, fieldValue.Addr().Interface()); e != nil {
                return nil, fmt.Errorf("failed to read binary data for field %s (%s): %w", fieldType.Name, fieldValue.Kind(), e)
            }
        }
    }

    // 返回 p 所指向的实际结构体实例
    return p.Interface(), nil
}

// Packet 示例结构体
type Packet struct {
    ID      uint16
    Version uint8
    Message string
    Count   int32
}

func main() {
    // 模拟要反序列化的字节数据
    // ID: 0x0001 (1)
    // Version: 0x02 (2)
    // Message长度: 0x0005 (5)
    // Message: "Hello"
    // Count: 0x0000000A (10)
    data := []byte{
        0x00, 0x01, // ID: 1
        0x02,       // Version: 2
        0x00, 0x05, // Message length: 5
        'H', 'e', 'l', 'l', 'o', // Message: "Hello"
        0x00, 0x00, 0x00, 0x0A, // Count: 10
    }

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

    // 将 interface{} 转换为实际的结构体指针类型
    if p, ok := unmarshaledPkt.(*Packet); ok {
        fmt.Printf("Unmarshaled Packet: %+v\n", p)
        // 预期输出: Unmarshaled Packet: &{ID:1 Version:2 Message:Hello Count:10}
    } else {
        fmt.Println("Type assertion failed.")
    }
}