Go语言反射：动态解包结构体字段值到[]interface{}切片

package main

import (
    "fmt"
    "reflect"
)

// 定义一个示例结构体
type MyStruct struct {
    Foo string
    Bar int
    Baz bool
}

// unpackStruct 函数：将结构体字段值动态提取到 []interface{} 切片
func unpackStruct(a interface{}) []interface{} {
    // 获取接口a的值的反射对象
    s := reflect.ValueOf(a)

    // 如果传入的是指针，需要通过 .Elem() 获取其指向的值
    if s.Kind() == reflect.Ptr {
        s = s.Elem()
    }

    // 检查s是否为结构体类型，如果不是，则根据实际需求处理错误
    if s.Kind() != reflect.Struct {
        // 这里简化处理，实际应用中可能需要返回错误或panic
        fmt.Printf("Warning: unpackStruct expects a struct, got %s\n", s.Kind())
        return nil
    }

    // 创建一个与结构体字段数量相同的 []interface{} 切片
    ret := make([]interface{}, s.NumField())

    // 遍历结构体的所有字段
    for i := 0; i < s.NumField(); i++ {
        // 获取第i个字段的值，并将其转换为 interface{} 类型
        ret[i] = s.Field(i).Interface()
    }
    return ret
}

func main() {
    m := MyStruct{"Hello", 123, true}
    values := unpackStruct(m)
    fmt.Printf("解包后的字段值: %#v\n", values) // 输出: []interface {}{"Hello", 123, true}

    // 模拟数据库插入操作的参数传递
    // query := "INSERT INTO my_table (foo, bar, baz) VALUES (?, ?, ?)"
    // res, err := db.Exec(query, values...) // 这里的values...就是动态解包后的参数
    // if err != nil { /* handle error */ }
}

package main

import (
    "fmt"
    "reflect"
    "strings"
)

// User 结构体，包含db标签用于映射数据库列名
type User struct {
    ID   int    `db:"id"`
    Name string `db:"user_name"`
    Age  int    `db:"age"`
    City string // 没有db标签，将使用字段名的小写形式
}

// getStructFieldNames 动态获取结构体字段名（优先使用db标签，否则转小写）
func getStructFieldNames(a interface{}) []string {
    t := reflect.TypeOf(a)
    if t.Kind() == reflect.Ptr {
        t = t.Elem() // 如果是指针，获取其指向的类型
    }
    if t.Kind() != reflect.Struct {
        return nil // 不是结构体类型
    }

    var names []string
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        // 优先使用结构体tag "db" 作为列名
        tagName := field.Tag.Get("db")
        if tagName != "" {
            names = append(names, tagName)
        } else {
            // 如果没有db标签，则将字段名转为小写作为列名
            names = append(names, strings.ToLower(field.Name))
        }
    }
    return names
}

// unpackStruct 提取结构体字段值到 []interface{}
func unpackStruct(a interface{}) []interface{} {
    s := reflect.ValueOf(a)
    if s.Kind() == reflect.Ptr {
        s = s.Elem() // 如果是指针，获取其指向的值
    }
    if s.Kind() != reflect.Struct {
        return nil // 不是结构体类型
    }

    ret := make([]interface{}, s.NumField())
    for i := 0; i < s.NumField(); i++ {
        ret[i] = s.Field(i).Interface()
    }
    return ret
}

func main() {
    user := User{ID: 1, Name: "Alice", Age: 30, City: "New York"}

    // 1. 获取字段名作为SQL列名
    columns := getStructFieldNames(user)
    fmt.Printf("SQL列名: %v\n", columns) // 输出: SQL列名: [id user_name age city]

    // 2. 获取字段值作为SQL参数
    values := unpackStruct(user)
    fmt.Printf("SQL参数值: %v\n", values) // 输出: SQL参数值: [1 Alice 30 New York]

    // 3. 构建动态SQL INSERT语句
    if len(columns) > 0 && len(values) == len(columns) {
        columnStr := strings.Join(columns, ", ")
        placeholders := make([]string, len(values))
        for i := range placeholders {
            placeholders[i] = "?"
        }
        placeholderStr := strings.Join(placeholders, ", ")

        sqlQuery := fmt.Sprintf("INSERT INTO users (%s) VALUES (%s)", columnStr, placeholderStr)
        fmt.Printf("生成的SQL: %s\n", sqlQuery)
        // 实际数据库操作示例：
        // db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database")
        // if err != nil { log.Fatal(err) }
        // defer db.Close()
        // res, err := db.Exec(sqlQuery, values...)
        // if err != nil { log.Fatal(err) }
        // fmt.Printf("Insert ID: %d, Rows Affected: %d\n", res.LastInsertId(), res.RowsAffected())
    }
}