Go语言中动态解构结构体：使用反射创建[]interface{}

package main

import (
    "fmt"
    "reflect"
    "strings" // 用于字符串操作，例如构建SQL占位符
)

// MyStruct 定义一个示例结构体，用于演示解构
type MyStruct struct {
    Foo   string
    Bar   int
    IsActive bool `db:"active_status"` // 示例：带有struct tag的字段
    privateField string // 未导出字段，反射无法直接访问其值
}

// UnpackStruct 接收一个结构体（或指向结构体的指针），
// 并将其所有可导出字段的值动态地提取到一个 []interface{} 切片中。
// 如果传入的不是结构体或指向结构体的指针，或者遇到不可导出的字段，则返回错误。
func UnpackStruct(s interface{}) ([]interface{}, error) {
    val := reflect.ValueOf(s)

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

    // 确保传入的是一个结构体
    if val.Kind() != reflect.Struct {
        return nil, fmt.Errorf("UnpackStruct expects a struct or a pointer to a struct, got %v", val.Kind())
    }

    numFields := val.NumField()
    result := make([]interface{}, 0, numFields) // 预分配容量，但只添加可导出字段

    for i := 0; i < numFields; i++ {
        field := val.Field(i)
        // 检查字段是否可导出。只有可导出字段才能通过反射获取其值。
        if !field.CanInterface() {
            // 对于不可导出字段，我们通常选择跳过或返回错误。
            // 在此示例中，我们选择跳过，只将可导出字段添加到结果中。
            // 如果需要严格要求所有字段都可处理，可以改为返回错误：
            // return nil, fmt.Errorf("field %s is unexported and cannot be interfaced", val.Type().Field(i).Name)
            continue
        }
        result = append(result, field.Interface())
    }

    return result, nil
}

// GetStructFieldNames 辅助函数，用于获取结构体的可导出字段名。
// 如果结构体字段有 `db` tag，则优先使用 tag 值作为字段名。
func GetStructFieldNames(s interface{}) ([]string, error) {
    typ := reflect.TypeOf(s)

    // 如果传入的是指针，获取其指向的类型
    if typ.Kind() == reflect.Ptr {
        typ = typ.Elem()
    }

    // 确保传入的是一个结构体类型
    if typ.Kind() != reflect.Struct {
        return nil, fmt.Errorf("GetStructFieldNames expects a struct or a pointer to a struct, got %v", typ.Kind())
    }

    numFields := typ.NumField()
    names := make([]string, 0, numFields)

    for i := 0; i < numFields; i++ {
        field := typ.Field(i)
        // 检查字段是否可导出
        if field.IsExported() {
            // 优先使用 `db` tag 作为字段名
            if dbTag := field.Tag.Get("db"); dbTag != "" {
                names = append(names, dbTag)
            } else {
                names = append(names, field.Name)
            }
        }
    }
    return names, nil
}

func main() {
    // 示例结构体实例
    m := MyStruct{
        Foo:   "Hello Go",
        Bar:   42,
        IsActive: true,
        privateField: "internal", // 未导出字段
    }

    // 1. 动态获取结构体字段值
    fieldValues, err := UnpackStruct(m)
    if err != nil {
        fmt.Printf("解构结构体时发生错误: %v\n", err)
        return
    }
    fmt.Printf("动态解构的字段值: %#v\n", fieldValues)
    // 预期输出: []interface {}{"Hello Go", 42, true} (privateField被跳过)

    // 2. 动态获取结构体字段名 (通常用于构建SQL查询的列名部分)
    fieldNames, err := GetStructFieldNames(m)
    if err != nil {
        fmt.Printf("获取字段名时发生错误: %v\n", err)
        return
    }
    fmt.Printf("动态获取的字段名: %#v\n", fieldNames)
    // 预期输出: []string{"Foo", "Bar", "active_status"} (注意IsActive被tag替换)

    // 3. 结合使用，构建动态SQL插入语句 (模拟)
    tableName := "my_table"
    columns := strings.Join(fieldNames, ", ")
    placeholders := strings.Repeat("?, ", len(fieldNames))
    placeholders = strings.TrimSuffix(placeholders, ", ") // 移除末尾逗号和空格

    query := fmt.Sprintf("INSERT INTO %s ( %s ) VALUES ( %s )", tableName, columns, placeholders)
    fmt.Printf("生成的SQL查询: %s\n", query)
    // 预期输出: INSERT INTO my_table ( Foo, Bar, active_status ) VALUES ( ?, ?, ? )

    // 模拟数据库执行 (需要真实的数据库连接)
    // db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
    // if err != nil {
    //     log.Fatal(err)
    // }
    // defer db.Close()
    // res, err := db.Exec(query, fieldValues...) // 注意这里的 `...` 语法用于展开切片
    // if err != nil {
    //     fmt.Println("执行查询时发生错误:", err)
    // } else {
    //     rowsAffected, _ := res.RowsAffected()
    //     fmt.Printf("查询执行成功，影响行数: %d\n", rowsAffected)
    // }

    fmt.Println("\n--- 进一步测试 ---")

    // 示例：处理指针类型的结构体
    mPtr := &MyStruct{"Pointer Foo", 100, false, "ptr_internal"}
    fieldValuesPtr, err := UnpackStruct(mPtr)
    if err != nil {
        fmt.Printf("解构结构体指针时发生错误: %v\n", err)
    } else {
        fmt.Printf("动态解构指针的字段值: %#v\n", fieldValuesPtr)
    }

    fieldNamesPtr, err := GetStructFieldNames(mPtr)
    if err != nil {
        fmt.Printf("获取结构体指针字段名时发生错误: %v\n", err)
    } else {
        fmt.Printf("动态获取指针的字段名: %#v\n", fieldNamesPtr)
    }

    // 示例：传入非结构体类型
    _, err = UnpackStruct("not a struct")
    if err != nil {
        fmt.Printf("解构非结构体时发生预期错误: %v\n", err)
    }
}