答案是：通过reflect可递归访问嵌套结构体字段值、遍历所有字段并处理标签。1. 使用FieldByName逐层获取嵌套字段值，支持指针解引用；2. 递归遍历结构体所有字段，包括匿名和深层嵌套，结合StructField获取标签信息，实现动态操作。

在Go语言中，reflect 包提供了运行时动态操作类型和值的能力。处理嵌套结构体时，我们经常需要递归访问字段、读取标签、修改值或判断字段是否存在。下面是一些常见操作方法的汇总，帮助你高效使用 reflect 处理嵌套结构体。

1. 获取嵌套结构体字段值

通过反射遍历结构体及其嵌套字段，可以逐层访问内部字段的值。

示例：

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
    }
}

2. 遍历所有嵌套字段（包括匿名和深层嵌套）

使用递归方式遍历结构体中的每一个字段，无论嵌套多少层。

示例函数：

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 =
}

3. 修改嵌套字段的值

要修改字段值，原始传入的对象必须是指针，否则无法设置。

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:}}
}

4. 解析结构体标签（如 json、orm 等）

常用于序列化、数据库映射等场景，可结合嵌套字段一起处理。

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

基本上就这些核心操作。掌握这些模式后，你可以灵活构建配置解析器、ORM 映射工具、数据校验器等需要深度处理结构体的组件。关键是理解 reflect.Value 和 reflect.Type 的区别，注意指针解引用与 CanSet 判断，避免 panic。