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

type Object struct {
    Id     string
    Field1 string
    Field2 int
}

func (o *Object) SetField1(value string) {
    o.Field1 = value
    // 伪代码：直接使用硬编码的字符串 "Field1" 作为数据库列名
    // database.Update(o.Id, "Field1", o.Field1)
}

type Object struct {
    Id     string `db:"id"`
    Field1 string `db:"field_one"` // 数据库列名可能与Go字段名不同
    Field2 int    `db:"field_two"`
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type MyStruct struct {
        Name    string `json:"full_name" db:"user_name"`
        Age     int    `json:"user_age"`
        IsActive bool   `db:"active_status"`
    }

    // 创建一个MyStruct的实例（或直接使用类型）
    myObj := MyStruct{
        Name:    "John Doe",
        Age:     30,
        IsActive: true,
    }

    // 获取MyStruct的类型信息
    t := reflect.TypeOf(myObj)

    fmt.Println("--- 遍历结构体字段及其标签 ---")
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("字段名: %s\n", field.Name)
        fmt.Printf("  JSON标签: %s\n", field.Tag.Get("json"))
        fmt.Printf("  DB标签:   %s\n", field.Tag.Get("db"))
        fmt.Println("--------------------")
    }

    // 也可以通过字段名直接获取特定字段的标签
    field, found := t.FieldByName("Name")
    if found {
        fmt.Printf("通过字段名获取 'Name' 字段的DB标签: %s\n", field.Tag.Get("db"))
    }
}

--- 遍历结构体字段及其标签 ---
字段名: Name
  JSON标签: full_name
  DB标签:   user_name
--------------------
字段名: Age
  JSON标签: user_age
  DB标签:   
--------------------
字段名: IsActive
  JSON标签: 
  DB标签:   active_status
--------------------
通过字段名获取 'Name' 字段的DB标签: user_name

package main

import (
    "fmt"
    "reflect"
)

// Object 代表数据库中的一个对象
type Object struct {
    Id     string `db:"id"`
    Field1 string `db:"field_one"`
    Field2 int    `db:"field_two"`
}

// getDBFieldName 是一个辅助函数，用于根据结构体字段名和db标签获取数据库列名
// obj: 结构体实例或指向结构体的指针
// fieldName: 结构体字段的Go语言名称 (例如 "Field1")
func getDBFieldName(obj interface{}, fieldName string) (string, error) {
    val := reflect.ValueOf(obj)
    // 如果传入的是指针，则获取其指向的实际值
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }
    // 确保是结构体类型
    if val.Kind() != reflect.Struct {
        return "", fmt.Errorf("expected a struct or a pointer to a struct, got %s", val.Kind())
    }

    fieldType := val.Type()
    field, found := fieldType.FieldByName(fieldName)
    if !found {
        return "", fmt.Errorf("field '%s' not found in struct '%s'", fieldName, fieldType.Name())
    }

    dbTag := field.Tag.Get("db")
    if dbTag == "" {
        // 如果没有定义db标签，则默认使用Go字段名作为数据库列名
        return field.Name, nil
    }
    return dbTag, nil
}

// SetField1 方法现在使用辅助函数来获取数据库列名
func (o *Object) SetField1(value string) error {
    o.Field1 = value

    // 使用getDBFieldName获取与"Field1"对应的数据库列名
    dbColumnName, err := getDBFieldName(o, "Field1")
    if err != nil {
        return fmt.Errorf("failed to get DB column name for Field1: %w", err)
    }

    // 伪代码：使用动态获取的数据库列名进行更新
    fmt.Printf("数据库更新操作：ID=%s, 列名='%s', 值='%s'\n", o.Id, dbColumnName, o.Field1)
    // database.Update(o.Id, dbColumnName, o.Field1)
    return nil
}

func main() {
    obj := Object{Id: "user-123", Field1: "original value", Field2: 100}

    fmt.Println("--- 初始状态 ---")
    fmt.Printf("Object: %+v\n", obj)

    fmt.Println("\n--- 更新 Field1 ---")
    if err := obj.SetField1("new value for field one"); err != nil {
        fmt.Println("更新失败:", err)
    }
    fmt.Printf("Object (更新后): %+v\n", obj)

    // 示例：Field2没有db标签的情况
    // obj.Field2 = 200
    // dbColumnNameForField2, err := getDBFieldName(obj, "Field2")
    // if err != nil {
    //  fmt.Println("获取Field2列名失败:", err)
    // } else {
    //  fmt.Printf("Field2的数据库列名: '%s'\n", dbColumnNameForField2) // 应该输出 "Field2"
    // }
}

--- 初始状态 ---
Object: {Id:user-123 Field1:original value Field2:100}

--- 更新 Field1 ---
数据库更新操作：ID=user-123, 列名='field_one', 值='new value for field one'
Object (更新后): {Id:user-123 Field1:new value for field one Field2:100}

// UpdateField 是一个更通用的方法，通过反射更新指定字段并触发数据库更新
// fieldName: 结构体字段的Go语言名称 (例如 "Field1")
// value: 要设置的新值
func (o *Object) UpdateField(fieldName string, value interface{}) error {
    val := reflect.ValueOf(o).Elem() // 获取结构体实例的Value
    field := val.FieldByName(fieldName)

    if !field.IsValid() || !field.CanSet() {
        return fmt.Errorf("cannot set field '%s'", fieldName)
    }

    // 尝试将新值转换为字段的类型并设置
    fieldValue := reflect.ValueOf(value)
    if !fieldValue.Type().AssignableTo(field.Type()) {
        return fmt.Errorf("cannot assign value of type %s to field %s of type %s",
            fieldValue.Type(), fieldName, field.Type())
    }
    field.Set(fieldValue)

    // 获取数据库列名
    dbColumnName, err := getDBFieldName(o, fieldName)
    if err != nil {
        return fmt.Errorf("failed to get DB column name for %s: %w", fieldName, err)
    }

    // 伪代码：使用动态获取的数据库列名进行更新
    fmt.Printf("数据库更新操作：ID=%s, 列名='%s', 值='%v'\n", o.Id, dbColumnName, value)
    // database.Update(o.Id, dbColumnName, value)
    return nil
}

// 在main函数中调用示例：
// if err := obj.UpdateField("Field1", "another new value"); err != nil {
//     fmt.Println("通用更新失败:", err)
// }
// if err := obj.UpdateField("Field2", 999); err != nil {
//     fmt.Println("通用更新失败:", err)
// }
// fmt.Printf("Object (通用更新后): %+v\n", obj)