Go语言中利用结构体标签和反射实现字段名称的动态获取与数据库映射

type Object struct {
    Id     string
    Field1 string
    Field2 int
}

func (self *Object) SetField1(value string) {
    self.Field1 = value
    // 伪代码：这里的 "Field1" 是硬编码的字符串，如何避免？
    database.Update(self.Id, "Field1", self.Field1)
}

type Object struct {
    Id     string `db:"id_column"`
    Field1 string `db:"field1_db_column"`
    Field2 int    `db:"field2_db_column"`
}

package main

import (
    "fmt"
    "reflect"
)

// Object 结构体，包含数据库映射的结构体标签
type Object struct {
    Id     string `db:"id_column"`
    Field1 string `db:"field1_db_column"`
    Field2 int    `db:"field2_db_column"`
}

func main() {
    obj := Object{} // 创建一个Object实例，用于获取其类型信息
    objType := reflect.TypeOf(obj)

    fmt.Println("--- 结构体字段及其db标签 ---")
    // 遍历结构体的所有字段
    for i := 0; i < objType.NumField(); i++ {
        field := objType.Field(i) // 获取第i个StructField
        dbTag := field.Tag.Get("db") // 从StructField的Tag中获取键为"db"的值

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

--- 结构体字段及其db标签 ---
Go字段名: Id         | 数据库列名(db tag): id_column
Go字段名: Field1     | 数据库列名(db tag): field1_db_column
Go字段名: Field2     | 数据库列名(db tag): field2_db_column

package main

import (
    "fmt"
    "reflect"
)

type Object struct {
    Id     string `db:"id_column"`
    Field1 string `db:"field1_db_column"`
    Field2 int    `db:"field2_db_column"`
}

// 模拟数据库更新操作
func databaseUpdate(id, dbColumnName string, value interface{}) {
    fmt.Printf("模拟数据库更新：ID=%s, 列名=%s, 值=%v\n", id, dbColumnName, value)
}

// SetField1 方法，现在可以动态获取数据库列名
func (o *Object) SetField1(value string) {
    o.Field1 = value // 更新结构体字段

    // 使用反射获取Field1的db标签作为数据库列名
    objType := reflect.TypeOf(*o) // 获取Object的类型信息
    field, found := objType.FieldByName("Field1") // 根据Go字段名获取StructField
    if !found {
        fmt.Println("错误：未找到字段 Field1")
        return
    }

    dbColumnName := field.Tag.Get("db") // 获取db标签值
    if dbColumnName == "" {
        dbColumnName = field.Name // 如果没有db标签，则使用Go字段名作为数据库列名
    }

    // 调用模拟的数据库更新函数
    databaseUpdate(o.Id, dbColumnName, o.Field1)
}

// updateGenericField 是一个更通用的字段更新函数
// 它接受结构体指针、要更新的Go字段名字符串和新值
func updateGenericField(objPtr interface{}, goFieldName string, newValue interface{}) {
    // 确保传入的是指针，并且可以获取其底层元素的值
    val := reflect.ValueOf(objPtr)
    if val.Kind() != reflect.Ptr || val.IsNil() {
        fmt.Println("错误：updateGenericField 需要一个非nil的结构体指针")
        return
    }
    elem := val.Elem() // 获取指针指向的结构体值

    // 获取结构体的类型信息
    typ := elem.Type()

    // 根据Go字段名查找StructField
    field, found := typ.FieldByName(goFieldName)
    if !found {
        fmt.Printf("错误：未找到字段 %s\n", goFieldName)
        return
    }

    // 获取数据库列名：优先使用db标签，否则使用Go字段名
    dbColumnName := field.Tag.Get("db")
    if dbColumnName == "" {
        dbColumnName = field.Name
    }

    // 获取并更新结构体中的字段值
    fieldToUpdate := elem.FieldByName(goFieldName)
    if !fieldToUpdate.IsValid() {
        fmt.Printf("错误：字段 %s 无效。\n", goFieldName)
        return
    }
    if !fieldToUpdate.CanSet() {
        fmt.Printf("警告：字段 %s 不可设置，无法更新结构体实例。\n", goFieldName)
    } else {
        // 尝试设置新值，这里需要进行类型匹配和转换
        // 简化处理，实际应用中需更严谨地检查newValue的类型与fieldToUpdate的类型是否兼容
        newValReflect := reflect.ValueOf(newValue)
        if newValReflect.Type().ConvertibleTo(fieldToUpdate.Type()) {
            fieldToUpdate.Set(newValReflect.Convert(fieldToUpdate.Type()))
        } else {
            fmt.Printf("错误：新值类型 %s 与字段 %s 类型 %s 不兼容。\n",
                newValReflect.Type(), goFieldName, fieldToUpdate.Type())
            return
        }
    }

    // 假设ID字段总是存在且是string类型，用于数据库更新的标识
    idField := elem.FieldByName("Id")
    var id string
    if idField.IsValid() && idField.Kind() == reflect.String {
        id = idField.String()
    } else {
        fmt.Println("错误：无法获取ID字段进行数据库更新。")
        return
    }

    // 调用模拟的数据库更新函数，使用新的值
    databaseUpdate(id, dbColumnName, newValue)
}


func main() {
    obj := Object{Id: "obj123", Field1: "initial_value", Field2: 10}
    fmt.Println("--- 调用 SetField1 方法 ---")
    obj.SetField1("new_value_for_field1") // 调用特定字段的setter

    fmt.Println("\n--- 演示通用字段更新函数 ---")
    // 演示更新Field2
    updateGenericField(&obj, "Field2", 25