如何在 Golang 中使用反射从 JSON 创建对象？

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

func main() {
    // 定义 JSON 数据
    jsonStr := `{
        "name": "John Doe",
        "age": 30,
        "occupation": "Software Engineer"
    }`

    // 将 JSON 数据解码为 map[string]interface{}
    var data map[string]interface{}
    if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }

    // 创建要填充的目标对象类型
    type Person struct {
        Name        string
        Age         int
        Occupation  string
    }
    var person Person

    // 使用反射将 map[string]interface{} 中的数据填充到目标对象中
    t := reflect.TypeOf(person)

    for key, val := range data {
        // 获取目标对象中与 JSON 字段名称匹配的字段
        field, ok := t.FieldByName(key)
        if !ok {
            fmt.Printf("Field %s not found in type %s\n", key, t.Name())
            continue
        }

        // 获取字段的类型并将其转换为 val 的类型
        fieldType := field.Type
        fieldValue, err := typeConversion(fieldType, val)
        if err != nil {
            fmt.Printf("Error converting value for field %s: %v\n", key, err)
            continue
        }

        // 使用反射设置字段值
        v := reflect.ValueOf(&person)
        fieldValuePtr := reflect.ValueOf(fieldValue)
        v.Elem().FieldByName(key).Set(fieldValuePtr)
    }

    // 打印填充后的目标对象
    fmt.Println(person)
}

// 将 val 转换为 type 指定的类型
func typeConversion(t reflect.Type, val interface{}) (value interface{}, err error) {
    switch t.Kind() {
    case reflect.String:
        value = val.(string)
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        value = int(val.(float64))
    case reflect.Float32, reflect.Float64:
        value = val.(float64)
    default:
        err = fmt.Errorf("Unsupported type: %s", t)
    }
    return
}

{
    "id": 1,
    "name": "Product A",
    "price": 100.50,
    "quantity": 5
}

type Product struct {
    ID       int     `json:"id"`
    Name     string  `json:"name"`
    Price    float64 `json:"price"`
    Quantity int     `json:"quantity"`
}

// 将 JSON 响应解码到 map[string]interface{}
var data map[string]interface{}
if err := json.Unmarshal([]byte(jsonResponse), &data); err != nil {
    fmt.Println("Error decoding JSON:", err)
    return
}

// 创建目标对象
var product Product

// 使用反射将数据填充到目标对象中
t := reflect.TypeOf(product)

for key, val := range data {
    field, ok := t.FieldByName(key)
    if !ok {
        fmt.Printf("Field %s not found in type %s\n", key, t.Name())
        continue
    }

    fieldType := field.Type
    fieldValue, err := typeConversion(fieldType, val)
    if err != nil {
        fmt.Printf("Error converting value for field %s: %v\n", key, err)
        continue
    }

    v := reflect.ValueOf(&product)
    fieldValuePtr := reflect.ValueOf(fieldValue)
    v.Elem().FieldByName(key).Set(fieldValuePtr)
}

fmt.Println(product) // 打印填充后的目标对象