Go语言中利用反射与结构体标签实现动态字段更新

type Object struct {
    Id string
    Field1 string
    Field2 int
}

func (self *Object) SetField1(value string) {
    self.Field1 = value
    database.Update(self.Id, "Field1", self.Field1) // 硬编码了 "Field1"
}

type Object struct {
    Id     string `db:"id"`
    Field1 string `db:"field1"` // 映射到数据库的 "field1" 列
    Field2 int    `db:"field2"` // 映射到数据库的 "field2" 列
}

package main

import (
    "fmt"
    "reflect"
)

// Object 结构体定义，包含 db 标签
type Object struct {
    Id     string `db:"id"`
    Field1 string `db:"field1_column"` // 示例：字段名与数据库列名不同
    Field2 int    `db:"field2_count"`
    // 未加标签的字段，反射时其 db 标签为空
    InternalField string 
}

func main() {
    // 创建 Object 实例
    obj := Object{
        Id:            "123",
        Field1:        "Value1",
        Field2:        42,
        InternalField: "hidden",
    }

    // 获取结构体的 Type 信息
    // reflect.TypeOf(obj) 获取的是值类型，若要操作指针，则需 reflect.TypeOf(&obj).Elem()
    t := reflect.TypeOf(obj)

    fmt.Println("--- 遍历结构体字段及其 db 标签 ---")
    // 遍历结构体的所有字段
    for i := 0; i < t.NumField(); i++ {
        // 获取第 i 个字段的 StructField 信息
        field := t.Field(i)

        // 获取字段的名称
        fieldName := field.Name
        // 获取字段的 db 标签值
        dbTag := field.Tag.Get("db")

        fmt.Printf("Go字段名: %-15s | 数据库列名(db tag): %s\n", fieldName, dbTag)
    }

    fmt.Println("\n--- 动态获取特定字段的 db 标签 ---")
    // 假设我们知道要查找的Go字段名是 "Field1"
    if field, ok := t.FieldByName("Field1"); ok {
        fmt.Printf("Go字段名 'Field1' 对应的数据库列名: %s\n", field.Tag.Get("db"))
    } else {
        fmt.Println("字段 'Field1' 未找到。")
    }

    // 假设我们知道要查找的Go字段名是 "Id"
    if field, ok := t.FieldByName("Id"); ok {
        fmt.Printf("Go字段名 'Id' 对应的数据库列名: %s\n", field.Tag.Get("db"))
    } else {
        fmt.Println("字段 'Id' 未找到。")
    }
}

// GenericUpdateField 更新数据库中指定结构体实例的单个字段
// objPtr 必须是指向结构体的指针
// goFieldName 是 Go 结构体中的字段名 (例如 "Field1")
// newValue 是要更新的新值
func GenericUpdateField(objPtr interface{}, goFieldName string, newValue interface{}) error {
    val := reflect.ValueOf(objPtr)
    if val.Kind() != reflect.Ptr || val.IsNil() {
        return fmt.Errorf("objPtr 必须是非空的结构体指针")
    }
    elem := val.Elem() // 获取指针指向的结构体值
    if elem.Kind() != reflect.Struct {
        return fmt.Errorf("objPtr 必须指向一个结构体")
    }

    // 获取结构体类型信息
    typ := elem.Type()
    field, ok := typ.FieldByName(goFieldName)
    if !ok {
        return fmt.Errorf("结构体中未找到字段: %s", goFieldName)
    }

    dbColumnName := field.Tag.Get("db")
    if dbColumnName == "" {
        return fmt.Errorf("字段 %s 未定义 'db' 标签，无法映射到数据库列", goFieldName)
    }

    // 假设这里有一个数据库更新函数
    // 实际应用中，你可能需要根据 newValue 的类型进行适配
    fmt.Printf("模拟数据库更新：更新 ID 为 %v 的记录，将列 '%s' 设置为 '%v'\n",
        elem.FieldByName("Id").Interface(), dbColumnName, newValue)
    // database.Update(elem.FieldByName("Id").Interface(), dbColumnName, newValue)

    // 如果需要同时更新 Go 结构体实例的字段值
    fieldValue := elem.FieldByName(goFieldName)
    if fieldValue.CanSet() {
        // 确保 newValue 的类型与字段类型兼容
        newValReflect := reflect.ValueOf(newValue)
        if newValReflect.Type().ConvertibleTo(fieldValue.Type()) {
            fieldValue.Set(newValReflect.Convert(fieldValue.Type()))
        } else {
            return fmt.Errorf("新值类型 %s 与字段 %s 类型 %s 不兼容", newValReflect.Type(), goFieldName, fieldValue.Type())
        }
    } else {
        return fmt.Errorf("字段 %s 不可设置 (可能是未导出字段)", goFieldName)
    }

    return nil
}

// 示例用法
func main() {
    // ... (Object 结构体和 main 函数中的反射示例代码) ...

    myObject := &Object{
        Id:     "user-001",
        Field1: "Original Field1 Value",
        Field2: 100,
    }

    fmt.Println("\n--- 使用通用更新函数 ---")
    // 更新 Field1
    err := GenericUpdateField(myObject, "Field1", "Updated Field1 Value")
    if err != nil {
        fmt.Printf("更新 Field1 失败: %v\n", err)
    } else {
        fmt.Printf("更新后 myObject.Field1: %s\n", myObject.Field1)
    }

    // 更新 Field2
    err = GenericUpdateField(myObject, "Field2", 200)
    if err != nil {
        fmt.Printf("更新 Field2 失败: %v\n", err)
    } else {
        fmt.Printf("更新后 myObject.Field2: %d\n", myObject.Field2)
    }

    // 尝试更新不存在的字段
    err = GenericUpdateField(myObject, "NonExistentField", "some value")
    if err != nil {
        fmt.Printf("尝试更新不存在字段的错误: %v\n", err)
    }

    // 尝试更新没有 db 标签的字段
    err = GenericUpdateField(myObject, "InternalField", "new internal value")
    if err != nil {
        fmt.Printf("尝试更新无 db 标签字段的错误: %v\n", err)
    }
}