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 失败: %vn", err)         return     }      // 类型断言并打印结果     if pkt, ok := unmarshaledPkt.(*MyPacket); ok {         fmt.Printf("解组成功！n")         fmt.Printf("ID: %dn", pkt.ID)         fmt.Printf("Version: %dn", pkt.Version)         fmt.Printf("Name: %sn", pkt.Name)         fmt.Printf("Value: %dn", pkt.Value)         fmt.Printf("Active: %tn", pkt.Active)     } else {         fmt.Println("类型断言失败")     } }