Golang反射在协议编码中的应用 演示二进制数据的动态解析

struct tag

binary.Read

buf.ReadByte

reflect.Type

reflect.Value

reflect.Type

struct tag

tag:"len_field=BodyLength"

BodyLength

proto:"field_id,type,options"

package main

import (
    "encoding/binary"
    "fmt"
    "io"
    "reflect"
    "strconv"
    "strings"
)

// MyMessage 是一个示例协议消息结构体
type MyMessage struct {
    MsgType   uint8  `proto:"1,uint8"`
    MsgLen    uint16 `proto:"2,uint16"` // 消息体长度
    Payload   []byte `proto:"3,bytes,len_field=MsgLen"` // 消息体，长度由MsgLen字段决定
    Checksum  uint32 `proto:"4,uint32"`
}

// UnmarshalBinaryProto 示例函数：使用反射和标签解析二进制数据到结构体
func UnmarshalBinaryProto(r io.Reader, v interface{}) error {
    val := reflect.ValueOf(v)
    if val.Kind() != reflect.Ptr || val.IsNil() {
        return fmt.Errorf("target must be a non-nil pointer")
    }
    val = val.Elem() // 获取指针指向的实际结构体

    t := val.Type()
    fieldValues := make(map[string]interface{}) // 存储已解析的字段值，供后续字段引用（如长度字段）

    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        tag := field.Tag.Get("proto")
        if tag == "" {
            continue // 跳过没有 proto 标签的字段
        }

        tagParts := strings.Split(tag, ",")
        if len(tagParts) < 2 {
            return fmt.Errorf("malformed proto tag for field %s: %s", field.Name, tag)
        }

        // fieldID := tagParts[0] // 字段ID，如果协议有的话
        fieldType := tagParts[1] // 字段类型，如 uint8, uint16, bytes

        currentFieldVal := val.Field(i) // 获取当前字段的 reflect.Value

        switch fieldType {
        case "uint8":
            var data uint8
            if err := binary.Read(r, binary.BigEndian, &data); err != nil {
                return err
            }
            currentFieldVal.SetUint(uint64(data))
            fieldValues[field.Name] = data
        case "uint16":
            var data uint16
            if err := binary.Read(r, binary.BigEndian, &data); err != nil {
                return err
            }
            currentFieldVal.SetUint(uint64(data))
            fieldValues[field.Name] = data
        case "uint32":
            var data uint32
            if err := binary.Read(r, binary.BigEndian, &data); err != nil {
                return err
            }
            currentFieldVal.SetUint(uint64(data))
            fieldValues[field.Name] = data
        case "bytes":
            var length int
            // 检查是否有 len_field 选项
            for _, opt := range tagParts[2:] {
                if strings.HasPrefix(opt, "len_field=") {
                    lenFieldName := strings.TrimPrefix(opt, "len_field=")
                    if lVal, ok := fieldValues[lenFieldName]; ok {
                        length = int(reflect.ValueOf(lVal).Convert(reflect.TypeOf(0)).Int()) // 将长度字段的值转换为 int
                        break
                    } else {
                        return fmt.Errorf("length field '%s' not found or not yet parsed for field '%s'", lenFieldName, field.Name)
                    }
                }
            }
            if length == 0 && !strings.Contains(tag, "optional") { // 除非是可选字段，否则长度不能为0
                return fmt.Errorf("bytes field '%s' requires a 'len_field' tag option or explicit length", field.Name)
            }

            buf := make([]byte, length)
            if _, err := io.ReadFull(r, buf); err != nil {
                return err
            }
            currentFieldVal.SetBytes(buf)
            fieldValues[field.Name] = buf

        // 还可以继续添加其他类型，如 string, int64, float32, 甚至嵌套结构体
        default:
            return fmt.Errorf("unsupported field type in tag: %s for field %s", fieldType, field.Name)
        }
    }
    return nil
}

// 实际使用时，可以构造一个字节流来测试
// var data = []byte{
//     0x01, // MsgType
//     0x00, 0x05, // MsgLen = 5
//     0x01, 0x02, 0x03, 0x04, 0x05, // Payload
//     0xAA, 0xBB, 0xCC, 0xDD, // Checksum
// }
// msg := &MyMessage{}
// err := UnmarshalBinaryProto(bytes.NewReader(data), msg)
// if err != nil {
//     fmt.Println("Error:", err)
// } else {
//     fmt.Printf("Parsed Message: %+v\n", msg)
// }

proto

uint8

len_field=MsgLen

Payload

MsgLen

MsgLen

Payload