如何在Golang中使用反射设置字段值_Golang 反射字段设置实践

package main

import (
    "fmt"
    "reflect"
)

// User 定义一个示例结构体
type User struct {
    Name    string
    Age     int
    IsActive bool
    privateField string // 私有字段，反射无法直接设置
}

func main() {
    // 1. 创建一个结构体实例
    user := User{
        Name:    "Alice",
        Age:     30,
        IsActive: true,
        privateField: "secret",
    }
    fmt.Printf("原始User: %+v\n", user)

    // 2. 获取结构体的 reflect.Value，注意这里必须传递指针
    // reflect.ValueOf(&user) 会返回一个指向 user 的指针的 Value
    // .Elem() 会解引用这个指针，得到 user 结构体本身的 Value
    // 只有这样，其字段才是可设置的
    userValue := reflect.ValueOf(&user).Elem()

    // 3. 检查 userValue 是否是结构体
    if userValue.Kind() != reflect.Struct {
        fmt.Println("错误：userValue不是一个结构体")
        return
    }

    // 4. 通过字段名获取要设置的字段
    nameField := userValue.FieldByName("Name")
    ageField := userValue.FieldByName("Age")
    isActiveField := userValue.FieldByName("IsActive")
    privateField := userValue.FieldByName("privateField") // 尝试获取私有字段

    // 5. 检查字段是否存在且可设置
    // Name 字段
    if nameField.IsValid() && nameField.CanSet() {
        if nameField.Kind() == reflect.String {
            nameField.SetString("Bob") // 设置字符串值
        }
    } else {
        fmt.Printf("Name字段不可设置或不存在\n")
    }

    // Age 字段
    if ageField.IsValid() && ageField.CanSet() {
        if ageField.Kind() == reflect.Int {
            ageField.SetInt(25) // 设置整数值
        }
    } else {
        fmt.Printf("Age字段不可设置或不存在\n")
    }

    // IsActive 字段
    if isActiveField.IsValid() && isActiveField.CanSet() {
        if isActiveField.Kind() == reflect.Bool {
            isActiveField.SetBool(false) // 设置布尔值
        }
    } else {
        fmt.Printf("IsActive字段不可设置或不存在\n")
    }

    // 尝试设置私有字段
    if privateField.IsValid() && privateField.CanSet() {
        // 理论上这里不会进入，因为私有字段CanSet()会返回false
        if privateField.Kind() == reflect.String {
            privateField.SetString("new secret")
        }
    } else {
        fmt.Printf("privateField字段不可设置或不存在 (预期行为)\n")
    }

    fmt.Printf("修改后User: %+v\n", user)

    // 6. 演示一个更通用的设置函数
    fmt.Println("\n--- 使用通用函数设置 ---")
    type Product struct {
        ID   int
        Name string
        Price float64
    }
    p := Product{ID: 1, Name: "Laptop", Price: 1200.0}
    fmt.Printf("原始Product: %+v\n", p)

    if err := SetField(&p, "Name", "Gaming Laptop"); err != nil {
        fmt.Println("设置Name失败:", err)
    }
    if err := SetField(&p, "Price", 1500.50); err != nil {
        fmt.Println("设置Price失败:", err)
    }
    if err := SetField(&p, "ID", 2); err != nil {
        fmt.Println("设置ID失败:", err)
    }
    // 尝试设置不存在的字段
    if err := SetField(&p, "Description", "A powerful machine"); err != nil {
        fmt.Println("设置Description失败:", err)
    }
    // 尝试类型不匹配
    if err := SetField(&p, "Price", "not a number"); err != nil {
        fmt.Println("设置Price (类型不匹配) 失败:", err)
    }

    fmt.Printf("修改后Product: %+v\n", p)
}

// SetField 是一个通用函数，用于通过反射设置结构体的字段值
// targetStruct 必须是一个结构体指针
// fieldName 是要设置的字段名
// value 是要设置的新值
func SetField(targetStruct interface{}, fieldName string, value interface{}) error {
    structPtrValue := reflect.ValueOf(targetStruct)

    // 确保传入的是一个指针
    if structPtrValue.Kind() != reflect.Ptr {
        return fmt.Errorf("期望一个结构体指针，但得到了 %v", structPtrValue.Kind())
    }

    // 解引用指针，得到结构体本身
    structValue := structPtrValue.Elem()

    // 再次检查是否为结构体
    if structValue.Kind() != reflect.Struct {
        return fmt.Errorf("指针指向的不是一个结构体，而是 %v", structValue.Kind())
    }

    field := structValue.FieldByName(fieldName)
    if !field.IsValid() {
        return fmt.Errorf("字段 '%s' 不存在", fieldName)
    }

    if !field.CanSet() {
        return fmt.Errorf("字段 '%s' 不可设置 (可能是未导出字段或非地址值)", fieldName)
    }

    // 获取要设置的值的 reflect.Value
    newValue := reflect.ValueOf(value)

    // 检查类型是否兼容
    if !newValue.Type().AssignableTo(field.Type()) {
        // 尝试进行类型转换，例如 int 可以转换为 int64
        if newValue.Type().ConvertibleTo(field.Type()) {
            field.Set(newValue.Convert(field.Type()))
            return nil
        }
        return fmt.Errorf("字段 '%s' 类型不匹配，期望 %v，得到 %v", fieldName, field.Type(), newValue.Type())
    }

    field.Set(newValue)
    return nil
}

// ... (SetField 函数前面部分相同) ...

    // 获取要设置的值的 reflect.Value
    newValue := reflect.ValueOf(value)

    // 检查类型是否兼容
    if !newValue.Type().AssignableTo(field.Type()) {
        // 尝试进行类型转换，例如 int 可以转换为 int64
        if newValue.Type().ConvertibleTo(field.Type()) {
            field.Set(newValue.Convert(field.Type()))
            return nil
        }
        return fmt.Errorf("字段 '%s' 类型不匹配，期望 %v，得到 %v", fieldName, field.Type(), newValue.Type())
    }

    field.Set(newValue)
    return nil
}