Go语言反射机制：解决字节流反序列化到结构体时的不可寻址值问题

package main

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

// Unmarshal unpacks the binary data and stores it in the packet using
// reflection.
func Unmarshal(b []byte, t reflect.Type) (pkt interface{}, err error) {
    buf := bytes.NewBuffer(b)
    p := reflect.New(t) // p 是一个 reflect.Value，表示指向 t 类型新实例的指针

    // 问题根源：v = reflect.ValueOf(p) 导致 v 成为一个表示 *指针值* 的 reflect.Value
    // 而不是指针所指向的 *结构体值*
    v := reflect.ValueOf(p) 

    for i := 0; i < t.NumField(); i++ {
        f := v.Field(i) // 尝试从表示指针的 v 中获取字段
        // ... 省略了对 f.Kind() 的处理，因为这里 f 已经是错误的 reflect.Value

        // 当执行到这里时，f 是一个表示结构体字段的 reflect.Value。
        // 但由于 v 本身是表示指针的 reflect.Value，f 并没有被正确地关联到实际的结构体实例，
        // 导致 f.Addr() 尝试获取一个不可寻址的值的地址，从而引发 panic。
        // panic: reflect.Value.Addr of unaddressable value
        e := binary.Read(buf, binary.BigEndian, f.Addr())
        if e != nil {
            err = e
            return
        }
    }

    pkt = p.Interface() // 返回 p 指向的实际值
    return
}

// 示例结构体
type MyPacket struct {
    ID     int32
    Length int16
    Name   string
    Value  float32
}

func main() {
    // 示例二进制数据
    data := []byte{
        0x00, 0x00, 0x00, 0x01, // ID: 1
        0x00, 0x05, // Length: 5
        'H', 'e', 'l', 'l', 'o', // Name: "Hello"
        0x40, 0x49, 0x0f, 0xd0, // Value: 3.14 (float32)
    }

    pktType := reflect.TypeOf(MyPacket{})
    packet, err := Unmarshal(data, pktType)
    if err != nil {
        fmt.Println("Unmarshal error:", err)
        return
    }
    fmt.Printf("Unmarshal successful: %+v\n", packet)
}

package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
    "io" // 导入 io 包以处理 EOF
    "reflect"
)

// Unmarshal unpacks the binary data and stores it in the packet using
// reflection.
func Unmarshal(b []byte, t reflect.Type) (pkt interface{}, err error) {
    buf := bytes.NewBuffer(b)
    p := reflect.New(t) // p 是一个 reflect.Value，表示指向 t 类型新实例的指针

    // 修正：使用 p.Elem() 获取指针所指向的实际结构体值
    v := p.Elem() 

    for i := 0; i < t.NumField(); i++ {
        f := v.Field(i) // 现在 f 是实际结构体字段的 reflect.Value，并且是可寻址的

        // 检查字段是否可设置（Set），这是修改字段的前提
        if !f.CanSet() {
            return nil, fmt.Errorf("field %s is not settable", t.Field(i).Name)
        }

        switch f.Kind() {
        case reflect.String:
            // 字符串处理：先读取长度（这里假设是 int16）
            var l int16
            if e := binary.Read(buf, binary.BigEndian, &l); e != nil {
                if e == io.EOF {
                    return nil, fmt.Errorf("unexpected EOF when reading string length for field %s", t.Field(i).Name)
                }
                return nil, fmt.Errorf("failed to read string length for field %s: %w", t.Field(i).Name, e)
            }

            // 根据长度读取字符串的字节
            raw := make([]byte, l)
            n, e := buf.Read(raw)
            if e != nil {
                if e == io.EOF && n < int(l) {
                    return nil, fmt.Errorf("unexpected EOF when reading string data for field %s (expected %d bytes, got %d)", t.Field(i).Name, l, n)
                }
                return nil, fmt.Errorf("failed to read string data for field %s: %w", t.Field(i).Name, e)
            }
            if n < int(l) {
                return nil, fmt.Errorf("not enough bytes for string field %s (expected %d, got %d)", t.Field(i).Name, l, n)
            }

            // 将字节转换为字符串并设置到字段
            f.SetString(string(raw)) // 直接使用 string(raw) 效率更高
        case reflect.Int32, reflect.Int16, reflect.Float32: // 其他基本类型
            // 对于基本类型，可以直接使用 f.Addr() 获取其地址并传递给 binary.Read
            if e := binary.Read(buf, binary.BigEndian, f.Addr().Interface()); e != nil {
                if e == io.EOF {
                    return nil, fmt.Errorf("unexpected EOF when reading field %s (%s)", t.Field(i).Name, f.Kind())
                }
                return nil, fmt.Errorf("failed to read field %s (%s): %w", t.Field(i).Name, f.Kind(), e)
            }
        default:
            // 泛化处理其他可寻址类型，但需要确保类型兼容
            // 更好的做法是针对每种预期类型进行明确处理，或者实现一个通用的 Decoder 接口
            if f.CanAddr() {
                if e := binary.Read(buf, binary.BigEndian, f.Addr().Interface()); e != nil {
                    if e == io.EOF {
                        return nil, fmt.Errorf("unexpected EOF when reading field %s (%s)", t.Field(i).Name, f.Kind())
                    }
                    return nil, fmt.Errorf("failed to read field %s (%s): %w", t.Field(i).Name, f.Kind(), e)
                }
            } else {
                return nil, fmt.Errorf("unsupported or unaddressable field type for field %s: %s", t.Field(i).Name, f.Kind())
            }
        }
    }

    pkt = p.Interface() // 返回 p 指向的实际值
    return pkt, nil
}

// 示例结构体
type MyPacket struct {
    ID     int32
    Length int16
    Name   string
    Value  float32
}

func main() {
    // 示例二进制数据
    data := []byte{
        0x00, 0x00, 0x00, 0x01, // ID: 1 (int32)
        0x00, 0x05,             // Length: 5 (int16)
        'H', 'e', 'l', 'l', 'o', // Name: "Hello" (string, 5 bytes)
        0x40, 0x49, 0x0f, 0xd0, // Value: 3.14 (float32, IEEE 754 big-endian)
    }

    pktType := reflect.TypeOf(MyPacket{})
    packet, err := Unmarshal(data, pktType)
    if err != nil {
        fmt.Println("Unmarshal error:", err)
        return
    }
    fmt.Printf("Unmarshal successful: %+v\n", packet)
    // 预期输出: Unmarshal successful: &{ID:1 Length:5 Name:Hello Value:3.14}
}