Golang如何使用reflect创建结构体切片实例_Golang reflect结构体切片实例实践

type User struct {
    Name string
    Age  int
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 1. 获取目标结构体的reflect.Type
    userType := reflect.TypeOf(User{})

    // 2. 使用reflect.SliceOf创建一个切片类型，它的元素类型是userType
    sliceOfType := reflect.SliceOf(userType)

    // 3. 使用reflect.MakeSlice创建这个切片类型的实例
    // 这里我们创建一个初始长度为0，容量为0的切片
    dynamicSlice := reflect.MakeSlice(sliceOfType, 0, 0)

    // 4. 动态创建结构体实例并添加到切片中
    // 创建第一个User实例
    user1Value := reflect.New(userType).Elem() // 注意这里的.Elem()，非常关键！
    user1Value.FieldByName("Name").SetString("Alice")
    user1Value.FieldByName("Age").SetInt(30)

    // 将第一个实例添加到切片
    dynamicSlice = reflect.Append(dynamicSlice, user1Value)

    // 创建第二个User实例
    user2Value := reflect.New(userType).Elem()
    user2Value.FieldByName("Name").SetString("Bob")
    user2Value.FieldByName("Age").SetInt(25)

    // 将第二个实例添加到切片
    dynamicSlice = reflect.Append(dynamicSlice, user2Value)

    // 5. 验证结果
    fmt.Printf("动态创建的切片类型: %v\n", dynamicSlice.Type())
    fmt.Printf("动态创建的切片长度: %d\n", dynamicSlice.Len())
    fmt.Printf("动态创建的切片内容: %v\n", dynamicSlice.Interface())

    // 遍历并打印切片中的元素
    for i := 0; i < dynamicSlice.Len(); i++ {
        elem := dynamicSlice.Index(i)
        fmt.Printf("元素 %d: Name=%s, Age=%d\n", i,
            elem.FieldByName("Name").String(),
            elem.FieldByName("Age").Int())
    }

    // 尝试将切片断言回原始类型（如果知道的话）
    if concreteSlice, ok := dynamicSlice.Interface().([]User); ok {
        fmt.Printf("断言回 []User 成功: %v\n", concreteSlice)
    } else {
        fmt.Println("断言回 []User 失败")
    }
}

// 错误示范：直接对指针Value操作
// userValuePtr := reflect.New(userType) // 这是一个 *User 的 reflect.Value
// userValuePtr.FieldByName("Name").SetString("Error") // 会panic，因为userValuePtr没有Name字段

// 正确做法：获取指向的值
// userValue := reflect.New(userType).Elem() // 这是一个 User 的 reflect.Value
// userValue.FieldByName("Name").SetString("Correct")

package main

import (
    "fmt"
    "reflect"
)

type Product struct {
    ID   int
    Name string
    Price float64
    Tags []string
}

// SetStructFields 尝试安全地设置结构体的字段
func SetStructFields(obj reflect.Value, data map[string]interface{}) error {
    if obj.Kind() != reflect.Struct {
        return fmt.Errorf("期望一个结构体类型，但得到 %v", obj.Kind())
    }

    for key, val := range data {
        field := obj.FieldByName(key)
        if !field.IsValid() {
            fmt.Printf("警告: 字段 '%s' 不存在或不可访问，跳过。\n", key)
            continue
        }
        if !field.CanSet() {
            return fmt.Errorf("字段 '%s' 不可设置", key)
        }

        // 尝试类型转换并设置
        switch field.Kind() {
        case reflect.String:
            if s, ok := val.(string); ok {
                field.SetString(s)
            } else {
                return fmt.Errorf("字段 '%s' 期望 string，但得到 %T", key, val)
            }
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            if i, ok := val.(int); ok { // 假设输入是int
                field.SetInt(int64(i))
            } else if f, ok := val.(float64); ok { // JSON unmarshal数字默认是float64
                field.SetInt(int64(f))
            } else {
                return fmt.Errorf("字段 '%s' 期望 int，但得到 %T", key, val)
            }
        case reflect.Float32, reflect.Float64:
            if f, ok := val.(float64); ok {
                field.SetFloat(f)
            } else if i, ok := val.(int); ok { // int也可以转float
                field.SetFloat(float64(i))
            } else {
                return fmt.Errorf("字段 '%s' 期望 float，但得到 %T", key, val)
            }
        case reflect.Slice:
            // 假设是 []string
            if s, ok := val.([]interface{}); ok { // JSON unmarshal切片元素默认是interface{}
                sliceType := field.Type()
                if sliceType.Elem().Kind() == reflect.String {
                    newSlice := reflect.MakeSlice(sliceType, 0, len(s))
                    for _, item := range s {
                        if strItem, ok := item.(string); ok {
                            newSlice = reflect.Append(newSlice, reflect.ValueOf(strItem))
                        } else {
                            return fmt.Errorf("字段 '%s' 的切片元素期望 string，但得到 %T", key, item)
                        }
                    }
                    field.Set(newSlice)
                } else {
                    return fmt.Errorf("字段 '%s' 切片元素类型不匹配", key)
                }
            } else {
                return fmt.Errorf("字段 '%s' 期望 []interface{}，但得到 %T", key, val)
            }
        // 更多类型处理...
        default:
            return fmt.Errorf("字段 '%s' 类型 %v 暂不支持自动填充", key, field.Kind())
        }
    }
    return nil
}

func main() {
    productType := reflect.TypeOf(Product{})
    sliceOfType := reflect.SliceOf(productType)
    dynamicProducts := reflect.MakeSlice(sliceOfType, 0, 0)

    productData1 := map[string]interface{}{
        "ID":    101,
        "Name":  "Laptop",
        "Price": 1200.50,
        "Tags":  []interface{}{"电子产品", "办公"},
    }
    productData2 := map[string]interface{}{
        "ID":    102,
        "Name":  "Mouse",
        "Price": 25,
        "Tags":  []interface{}{"外设"},
        "InvalidField": "should be ignored", // 演示不存在的字段
    }

    for _, data := range []map[string]interface{}{productData1, productData2} {
        newProductValue := reflect.New(productType).Elem()
        if err := SetStructFields(newProductValue, data); err != nil {
            fmt.Printf("填充数据失败: %v\n", err)
            continue
        }
        dynamicProducts = reflect.Append(dynamicProducts, newProductValue)
    }

    fmt.Printf("最终产品切片: %v\n", dynamicProducts.Interface())
}