Golang如何实现反射修改嵌套结构体字段_Golang 嵌套结构体字段修改实践

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

// Person 包含嵌套的 Address 结构体
type Person struct {
    Name    string
    Age     int
    Address Address
    Contact *Contact // 指针类型嵌套
    ID      string   `json:"id"` // 带有tag的字段
}

// Address 嵌套结构体
type Address struct {
    Street string
    City   string
    Zip    string
}

// Contact 另一个嵌套结构体
type Contact struct {
    Email string
    Phone string
}

// SetNestedField 通过反射修改任意深度嵌套的结构体字段
// obj 必须是一个指向结构体的指针
// fieldPath 是字段路径，例如 "Address.Street" 或 "Contact.Email"
// newValue 是要设置的新值
func SetNestedField(obj interface{}, fieldPath string, newValue interface{}) error {
    v := reflect.ValueOf(obj)
    // 确保传入的是指针，反射才能修改其指向的值
    if v.Kind() != reflect.Ptr || v.IsNil() {
        return fmt.Errorf("obj must be a non-nil pointer to a struct")
    }
    v = v.Elem() // 获取指针指向的实际值

    if v.Kind() != reflect.Struct {
        return fmt.Errorf("obj must point to a struct, got %s", v.Kind())
    }

    pathSegments := parseFieldPath(fieldPath) // 简单的路径解析，例如 "User.Address.Street" -> ["User", "Address", "Street"]

    currentField := v
    for i, segment := range pathSegments {
        if currentField.Kind() == reflect.Ptr {
            if currentField.IsNil() {
                // 如果是nil指针，尝试创建实例
                newPtr := reflect.New(currentField.Type().Elem())
                currentField.Set(newPtr)
            }
            currentField = currentField.Elem() // 解引用指针
        }

        if currentField.Kind() != reflect.Struct {
            return fmt.Errorf("path segment '%s' is not a struct, but %s", segment, currentField.Kind())
        }

        field := currentField.FieldByName(segment)
        if !field.IsValid() {
            // 尝试通过JSON tag查找字段
            found := false
            for j := 0; j < currentField.NumField(); j++ {
                structField := currentField.Type().Field(j)
                if tag, ok := structField.Tag.Lookup("json"); ok && tag == segment {
                    field = currentField.Field(j)
                    found = true
                    break
                }
            }
            if !found {
                return fmt.Errorf("field '%s' not found in struct", segment)
            }
        }

        if i < len(pathSegments)-1 { // 不是最后一个字段，继续深入
            currentField = field
        } else { // 最后一个字段，准备修改
            if !field.CanSet() {
                return fmt.Errorf("field '%s' is not settable (unexported or unaddressable)", segment)
            }

            // 类型转换与设置
            newVal := reflect.ValueOf(newValue)
            if !newVal.Type().ConvertibleTo(field.Type()) {
                // 尝试一些基本类型的转换，例如string转int
                if field.Kind() == reflect.Int && newVal.Kind() == reflect.String {
                    if intVal, err := strconv.Atoi(newVal.String()); err == nil {
                        field.SetInt(int64(intVal))
                        return nil
                    }
                }
                return fmt.Errorf("cannot convert new value type %s to field type %s", newVal.Type(), field.Type())
            }
            field.Set(newVal.Convert(field.Type()))
        }
    }
    return nil
}

// 简单的路径解析函数
func parseFieldPath(path string) []string {
    // 这里可以根据实际需求实现更复杂的解析，例如支持数组索引等
    return splitString(path, ".")
}

// splitString 辅助函数，避免使用strings.Split
func splitString(s, sep string) []string {
    var result []string
    start := 0
    for i := 0; i < len(s); i++ {
        if i+len(sep) <= len(s) && s[i:i+len(sep)] == sep {
            result = append(result, s[start:i])
            start = i + len(sep)
        }
    }
    result = append(result, s[start:])
    return result
}

func main() {
    p := &Person{
        Name: "Alice",
        Age:  30,
        Address: Address{
            Street: "123 Main St",
            City:   "Anytown",
            Zip:    "12345",
        },
        Contact: nil, // 初始为nil
    }

    fmt.Println("Original Person:", p)

    // 修改顶层字段
    err := SetNestedField(p, "Name", "Bob")
    if err != nil {
        fmt.Println("Error modifying Name:", err)
    }
    fmt.Println("After modifying Name:", p)

    // 修改嵌套结构体字段
    err = SetNestedField(p, "Address.Street", "456 Oak Ave")
    if err != nil {
        fmt.Println("Error modifying Address.Street:", err)
    }
    fmt.Println("After modifying Address.Street:", p)

    // 修改嵌套指针结构体字段（初始为nil）
    err = SetNestedField(p, "Contact.Email", "bob@example.com")
    if err != nil {
        fmt.Println("Error modifying Contact.Email:", err)
    }
    fmt.Println("After modifying Contact.Email (was nil):", p)

    // 修改带有tag的字段
    err = SetNestedField(p, "id", "new-person-id-123") // 尝试用tag名修改
    if err != nil {
        fmt.Println("Error modifying ID by tag:", err)
    }
    fmt.Println("After modifying ID by tag:", p)

    // 尝试类型不匹配的修改
    err = SetNestedField(p, "Age", "forty") // 字符串转int
    if err != nil {
        fmt.Println("Error modifying Age with string:", err)
    }
    fmt.Println("After modifying Age with string:", p)
}