Go语言中基于字符串名称的结构体动态创建与JSON反序列化限制

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
    "sync" // 用于并发安全的类型注册
)

// 定义需要动态实例化的结构体
type MyStructType struct {
    Id   int    `json:"Id"`
    Name string `json:"Name"`
    Desc string `json:"Desc"`
}

type AnotherStructType struct {
    Code    string `json:"Code"`
    Message string `json:"Message"`
}

// 类型注册中心
var (
    typeRegistry = make(map[string]reflect.Type)
    mu           sync.RWMutex // 保护typeRegistry的并发访问
)

// RegisterType 注册一个结构体类型，以便后续可以通过名称查找
func RegisterType(name string, sample interface{}) {
    mu.Lock()
    defer mu.Unlock()
    // 确保传入的是一个结构体指针或结构体本身
    val := reflect.ValueOf(sample)
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }
    if val.Kind() != reflect.Struct {
        panic("RegisterType expects a struct or a pointer to a struct")
    }
    typeRegistry[name] = val.Type()
    fmt.Printf("Registered type: %s -> %s\n", name, val.Type().String())
}

// init 函数用于在程序启动时注册所有可用的类型
func init() {
    RegisterType("MyStructType", MyStructType{})
    RegisterType("AnotherStructType", AnotherStructType{})
}

// CreateAndUnmarshalFromJSON 根据类型名称创建实例并反序列化JSON
func CreateAndUnmarshalFromJSON(jsonBytes []byte, typeName string) (interface{}, error) {
    mu.RLock()
    typ, ok := typeRegistry[typeName]
    mu.RUnlock()

    if !ok {
        return nil, fmt.Errorf("type '%s' not registered", typeName)
    }

    // 使用 reflect.New 创建一个指定类型的指针
    // 例如，如果typ是MyStructType，reflect.New(typ)会返回*MyStructType类型的值
    ptrToNewInstance := reflect.New(typ) // ptrToNewInstance 是一个 reflect.Value，代表 *MyStructType

    // ptrToNewInstance.Interface() 返回 *MyStructType 类型的 interface{}
    // json.Unmarshal 需要一个指向结构体的指针
    err := json.Unmarshal(jsonBytes, ptrToNewInstance.Interface())
    if err != nil {
        return nil, fmt.Errorf("failed to unmarshal JSON into type '%s': %w", typeName, err)
    }

    // 返回实际的结构体值（通过解引用指针）
    return ptrToNewInstance.Elem().Interface(), nil
}

func main() {
    // 示例数据
    myStructJSON := []byte(`{"Id":3,"Name":"Jack","Desc":"the man"}`)
    anotherStructJSON := []byte(`{"Code":"ERR-001","Message":"Something went wrong"}`)

    // 动态反序列化 MyStructType
    myStructInstance, err := CreateAndUnmarshalFromJSON(myStructJSON, "MyStructType")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        // 类型断言，将 interface{} 转换为具体的结构体类型
        if ms, ok := myStructInstance.(MyStructType); ok {
            fmt.Printf("Unmarshal MyStructType: %+v\n", ms)
            fmt.Printf("Id: %d, Name: %s\n", ms.Id, ms.Name)
        } else {
            fmt.Println("Unexpected type after unmarshal for MyStructType")
        }
    }

    fmt.Println("---")

    // 动态反序列化 AnotherStructType
    anotherStructInstance, err := CreateAndUnmarshalFromJSON(anotherStructJSON, "AnotherStructType")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        if as, ok := anotherStructInstance.(AnotherStructType); ok {
            fmt.Printf("Unmarshal AnotherStructType: %+v\n", as)
            fmt.Printf("Code: %s, Message: %s\n", as.Code, as.Message)
        } else {
            fmt.Println("Unexpected type after unmarshal for AnotherStructType")
        }
    }

    fmt.Println("---")

    // 尝试反序列化一个未注册的类型
    _, err = CreateAndUnmarshalFromJSON([]byte(`{}`), "NonExistentType")
    if err != nil {
        fmt.Println("Error for non-existent type:", err)
    }
}