如何在Golang中使用reflect处理嵌套结构体_Golang reflect嵌套结构体操作方法汇总

package main

import (
    "fmt"
    "reflect"
)

type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Age     int
    Addr    Address
}

func getNestedField(obj interface{}, fields ...string) reflect.Value {
    v := reflect.ValueOf(obj)
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }

    for _, name := range fields {
        if v.Kind() != reflect.Struct {
            return reflect.Value{}
        }
        v = v.FieldByName(name)
        if !v.IsValid() {
            return reflect.Value{}
        }
        // 如果字段是嵌套指针，解引用
        if v.Kind() == reflect.Ptr && !v.IsNil() {
            v = v.Elem()
        }
    }
    return v
}

func main() {
    p := Person{
        Name: "Alice",
        Age:  30,
        Addr: Address{City: "Beijing", State: "CN"},
    }

    cityV := getNestedField(p, "Addr", "City")
    if cityV.IsValid() {
        fmt.Println("City:", cityV.String()) // 输出：City: Beijing
    }
}

func walkStruct(v reflect.Value, fn func(field reflect.Value, t reflect.StructField)) {
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }
    if v.Kind() != reflect.Struct {
        return
    }

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

        // 处理匿名字段（嵌入式结构体）
        if ft.Anonymous {
            walkStruct(fv, fn)
            continue
        }

        // 递归处理嵌套结构体
        if fv.Kind() == reflect.Struct {
            walkStruct(fv, fn)
        }

        // 执行回调
        fn(fv, ft)
    }
}

func main() {
    p := Person{
        Name: "Bob",
        Addr: Address{City: "Shanghai"},
    }

    walkStruct(reflect.ValueOf(p), func(field reflect.Value, t reflect.StructField) {
        if field.Kind() == reflect.String {
            fmt.Printf("%s = %s\n", t.Name, field.String())
        }
    })
    // 输出：
    // Name = Bob
    // City = Shanghai
    // State =
}

func setNestedField(obj interface{}, value interface{}, fields ...string) bool {
    v := reflect.ValueOf(obj)
    if v.Kind() != reflect.Ptr || v.IsNil() {
        return false
    }
    v = v.Elem()

    for i, name := range fields {
        if v.Kind() != reflect.Struct {
            return false
        }
        f := v.FieldByName(name)
        if !f.IsValid() {
            return false
        }

        // 若是最后一层，尝试赋值
        if i == len(fields)-1 {
            if f.CanSet() && reflect.TypeOf(value).AssignableTo(f.Type()) {
                f.Set(reflect.ValueOf(value))
                return true
            }
            return false
        }

        // 否则进入下一层
        if f.Kind() == reflect.Ptr && f.IsNil() {
            newVal := reflect.New(f.Type().Elem())
            f.Set(newVal)
            f = newVal.Elem()
        } else if f.Kind() == reflect.Ptr {
            f = f.Elem()
        }
        v = f
    }
    return false
}

func main() {
    var p Person
    setNestedField(&p, "New York", "Addr", "City")
    setNestedField(&p, "Charlie", "Name")
    fmt.Printf("%+v\n", p)
    // 输出：{Name:Charlie Age:0 Addr:{City:New York State:}}
}

func printTags(obj interface{}) {
    v := reflect.ValueOf(obj)
    t := v.Type()

    for i := 0; i < v.NumField(); i++ {
        sf := t.Field(i)
        if sf.Anonymous {
            // 递归处理匿名嵌套
            if sf.Type.Kind() == reflect.Struct {
                printTags(v.Field(i).Interface())
            }
            continue
        }

        if tag := sf.Tag.Get("json"); tag != "" {
            fmt.Printf("Field: %s, json tag: %s\n", sf.Name, tag)
        }
    }
}

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    Addr Address `json:"address"`
}

Field: Name, json tag: name
Field: Age, json tag: age
Field: Addr, json tag: address