如何在Golang中使用reflect实现序列化_Golang reflect序列化操作方法汇总

func inspectStruct(obj interface{}) {
    v := reflect.ValueOf(obj)
    if v.Kind() == reflect.Ptr {
        v = v.Elem() // 解引用
    }
    t := v.Type()
<pre class="brush:php;toolbar:false;"><pre class="brush:php;toolbar:false;">for i := 0; i < v.NumField(); i++ {
    field := v.Field(i)
    structField := t.Field(i)
    tagName := structField.Tag.Get("json")
    if tagName == "" {
        tagName = structField.Name
    }
    fmt.Printf("字段名: %s, Tag: %s, 值: %v\n", structField.Name, tagName, field.Interface())
}

func structToMap(obj interface{}) (map[string]interface{}, error) {
    result := make(map[string]interface{})
    v := reflect.ValueOf(obj)
<pre class="brush:php;toolbar:false;"><pre class="brush:php;toolbar:false;">if v.Kind() == reflect.Ptr {
    v = v.Elem()
}

if v.Kind() != reflect.Struct {
    return nil, fmt.Errorf("输入必须是结构体")
}

t := v.Type()
for i := 0; i < v.NumField(); i++ {
    field := v.Field(i)
    fieldType := t.Field(i)

    if !field.CanInterface() {
        continue // 跳过不可访问字段
    }

    key := fieldType.Tag.Get("json")
    if key == "" {
        key = fieldType.Name
    }
    if key == "-" {
        continue // 忽略标记为 - 的字段
    }

    // 忽略零值（可选）
    if reflect.DeepEqual(field.Interface(), reflect.Zero(field.Type()).Interface()) {
        continue
    }

    result[key] = field.Interface()
}
return result, nil

func serializeValue(v reflect.Value) interface{} {
    switch v.Kind() {
    case reflect.Struct:
        m := make(map[string]interface{})
        t := v.Type()
        for i := 0; i < v.NumField(); i++ {
            fv := v.Field(i)
            ft := t.Field(i)
            key := ft.Tag.Get("json")
            if key == "" {
                key = ft.Name
            }
            if key == "-" {
                continue
            }
            m[key] = serializeValue(fv)
        }
        return m
<pre class="brush:php;toolbar:false;"><pre class="brush:php;toolbar:false;">case reflect.Slice, reflect.Array:
    var items []interface{}
    for i := 0; i < v.Len(); i++ {
        items = append(items, serializeValue(v.Index(i)))
    }
    return items

case reflect.Ptr:
    if v.IsNil() {
        return nil
    }
    return serializeValue(v.Elem())

default:
    return v.Interface()
}

type Serializable interface {
    Serialize() interface{}
}
<p>// 在 serializeValue 中加入判断：
if v.Type().Implements(reflect.TypeOf((*Serializable)(nil)).Elem()) {
method := v.MethodByName("Serialize")
out := method.Call(nil)
return out[0].Interface()
}