Golang如何通过反射获取嵌套结构体字段_Golang 嵌套结构体字段获取实践

package main

import (
    "fmt"
    "reflect"
    "strings"
)

type Address struct {
    Street string
    City   string
}

type User struct {
    Name    string
    Age     int
    Contact Address // 嵌套结构体
    secret  string  // 未导出字段
}

// getNestedField 通过点分隔的路径获取嵌套结构体字段的 reflect.Value
func getNestedField(obj interface{}, path string) (reflect.Value, error) {
    val := reflect.ValueOf(obj)

    // 如果传入的是指针，解引用
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    // 确保是结构体类型
    if val.Kind() != reflect.Struct {
        return reflect.Value{}, fmt.Errorf("expected a struct or a pointer to a struct, got %s", val.Kind())
    }

    parts := strings.Split(path, ".")
    currentVal := val

    for i, part := range parts {
        field := currentVal.FieldByName(part) // 尝试按名称获取字段
        if !field.IsValid() {
            // 字段不存在或未导出，FieldByName会返回无效的reflect.Value
            return reflect.Value{}, fmt.Errorf("field '%s' not found or is unexported in path '%s'", part, path)
        }

        // 如果是路径中的最后一个字段，直接返回
        if i == len(parts)-1 {
            return field, nil
        }

        // 如果不是最后一个字段，且是结构体或指向结构体的指针，则继续深入
        if field.Kind() == reflect.Struct {
            currentVal = field
        } else if field.Kind() == reflect.Ptr && field.Elem().Kind() == reflect.Struct {
            currentVal = field.Elem()
        } else {
            // 中间字段不是结构体或指向结构体的指针，无法继续深入
            return reflect.Value{}, fmt.Errorf("intermediate field '%s' in path '%s' is not a struct or pointer to struct", part, path)
        }
    }
    // 理论上不会走到这里，除非路径为空或处理逻辑有误
    return reflect.Value{}, fmt.Errorf("path processing error for '%s'", path)
}

func main() {
    user := User{
        Name: "Alice",
        Age:  30,
        Contact: Address{
            Street: "123 Main St",
            City:   "Anytown",
        },
        secret: "top_secret_data", // 未导出字段
    }

    // 获取普通字段
    if nameField, err := getNestedField(user, "Name"); err == nil {
        fmt.Printf("Name: %v (Type: %s)\n", nameField.Interface(), nameField.Type())
    } else {
        fmt.Println("Error getting Name:", err)
    }

    // 获取嵌套结构体字段
    if streetField, err := getNestedField(user, "Contact.Street"); err == nil {
        fmt.Printf("Street: %v (Type: %s)\n", streetField.Interface(), streetField.Type())
    } else {
        fmt.Println("Error getting Contact.Street:", err)
    }

    // 尝试获取不存在的字段
    if invalidField, err := getNestedField(user, "Contact.ZipCode"); err == nil {
        fmt.Printf("ZipCode: %v\n", invalidField.Interface())
    } else {
        fmt.Println("Error getting Contact.ZipCode (expected):", err)
    }

    // 尝试获取未导出字段（会失败）
    if secretField, err := getNestedField(user, "secret"); err == nil {
        fmt.Printf("Secret: %v\n", secretField.Interface())
    } else {
        fmt.Println("Error getting secret (expected):", err) // 预期会报错
    }

    // 使用指针作为输入
    userPtr := &User{
        Name: "Bob",
        Contact: Address{
            City: "Sometown",
        },
    }
    if cityField, err := getNestedField(userPtr, "Contact.City"); err == nil {
        fmt.Printf("City (from ptr): %v (Type: %s)\n", cityField.Interface(), cityField.Type())
    } else {
        fmt.Println("Error getting Contact.City (from ptr):", err)
    }
}

fieldValue := // 通过反射获取到的 reflect.Value
if strVal, ok := fieldValue.Interface().(string); ok {
    fmt.Printf("字段是字符串: %s\n", strVal)
} else if intVal, ok := fieldValue.Interface().(int); ok {
    fmt.Printf("字段是整数: %d\n", intVal)
} else {
    fmt.Printf("字段类型未知或不匹配: %T\n", fieldValue.Interface())
}

if fieldValue.Kind() == reflect.String {
    strVal := fieldValue.String() // 安全，因为已经检查过Kind
    fmt.Printf("字段是字符串: %s\n", strVal)
} else if fieldValue.Kind() == reflect.Int {
    intVal := fieldValue.Int() // 安全
    fmt.Printf("字段是整数: %d\n", intVal)
}

type MyCustomType struct {
    Value string
}

// ... 假设fieldValue是一个MyCustomType类型的值
if customVal, ok := fieldValue.Interface().(MyCustomType); ok {
    fmt.Printf("字段是自定义类型，其Value是: %s\n", customVal.Value)
} else {
    // 处理类型不匹配的情况
}