Go语言：通过字符串名称动态实例化结构体的可行性与反射实践

package main

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

// TypeRegistry 用于存储结构体类型及其名称的映射
type TypeRegistry struct {
    mu    sync.RWMutex // 读写锁，保证并发安全
    types map[string]reflect.Type
}

// NewTypeRegistry 创建一个新的类型注册表实例
func NewTypeRegistry() *TypeRegistry {
    return &TypeRegistry{
        types: make(map[string]reflect.Type),
    }
}

// RegisterType 注册一个结构体类型。
// typ参数可以是结构体值（如MyStructType{}）或结构体指针（如&MyStructType{}）。
// 注册时会自动获取其元素类型（如果传入的是指针）。
func (tr *TypeRegistry) RegisterType(name string, typ interface{}) {
    tr.mu.Lock()
    defer tr.mu.Unlock()

    rType := reflect.TypeOf(typ)
    // 如果传入的是指针类型，获取其指向的元素类型
    if rType.Kind() == reflect.Ptr {
        rType = rType.Elem()
    }
    tr.types[name] = rType
    fmt.Printf("Registered type: %s -> %v\n", name, rType)
}

// GetType 获取已注册的结构体类型
func (tr *TypeRegistry) GetType(name string) (reflect.Type, bool) {
    tr.mu.RLock()
    defer tr.mu.RUnlock()
    typ, ok := tr.types[name]
    return typ, ok
}

// UnmarshalFromJSONString 根据类型名称字符串反序列化JSON数据
// data: 待反序列化的JSON字节数组
// typeName: 注册表中对应的结构体名称字符串
// 返回值: 反序列化后的结构体实例（interface{}），或错误信息
func (tr *TypeRegistry) UnmarshalFromJSONString(data []byte, typeName string) (interface{}, error) {
    typ, ok := tr.GetType(typeName)
    if !ok {
        return nil, fmt.Errorf("type '%s' not registered", typeName)
    }

    // reflect.New(typ) 返回一个指向新分配的零值的指针（reflect.Value类型）
    // 例如，如果typ是MyStructType，newVal将是*MyStructType的reflect.Value
    newVal := reflect.New(typ)

    // 将JSON数据反序列化到新创建的实例中
    // newVal.Interface() 返回该reflect.Value所持有的值作为interface{}
    // 由于json.Unmarshal需要一个指针，这里newVal本身就是指针，所以直接传入其接口值即可
    err := json.Unmarshal(data, newVal.Interface())
    if err != nil {
        return nil, fmt.Errorf("failed to unmarshal JSON for type '%s': %w", typeName, err)
    }

    // 返回反序列化后的结构体实例的指针
    return newVal.Interface(), nil
}

// 定义一个示例结构体
type MyStructType struct {
    Id   int    `json:"Id"`
    Name string `json:"Name"`
    Desc string `json:"Desc"`
}

// 定义另一个示例结构体
type AnotherStruct struct {
    Code  string `json:"Code"`
    Value int    `json:"Value"`
}

func main() {
    // 1. 创建并初始化类型注册表
    registry := NewTypeRegistry()

    // 2. 注册所有需要动态使用的结构体类型
    // 可以注册结构体值或指针，RegisterType方法会处理获取元素类型
    registry.RegisterType("MyStructType", MyStructType{})
    registry.RegisterType("AnotherStruct", &AnotherStruct{})

    // 3. 准备JSON数据
    jsonData1 := []byte(`{"Id":3,"Name":"Jack","Desc":"the man"}`)
    jsonData2 := []byte(`{"Code":"ABC","Value":123}`)

    // 4. 使用注册表进行动态反序列化
    fmt.Println("\n--- Unmarshaling MyStructType ---")
    val1, err := registry.UnmarshalFromJSONString(jsonData1, "MyStructType")
    if err != nil {
        fmt.Println("Error unmarshaling MyStructType:", err)
    } else {
        // 反序列化成功后，需要进行类型断言才能使用具体类型的方法或字段
        if myStruct, ok := val1.(*MyStructType); ok {
            fmt.Printf("Successfully unmarshaled MyStructType: %+v\n", *myStruct)
            fmt.Printf("ID: %d, Name: %s\n", myStruct.Id, myStruct.Name)
        } else {
            fmt.Println("Failed to assert type for MyStructType")
        }
    }

    fmt.Println("\n--- Unmarshaling AnotherStruct ---")
    val2, err := registry.UnmarshalFromJSONString(jsonData2, "AnotherStruct")
    if err != nil {
        fmt.Println("Error unmarshaling AnotherStruct:", err)
    } else {
        if anotherStruct, ok := val2.(*AnotherStruct); ok {
            fmt.Printf("Successfully unmarshaled AnotherStruct: %+v\n", *anotherStruct)
            fmt.Printf("Code: %s, Value: %d\n", anotherStruct.Code, anotherStruct.Value)
        } else {
            fmt.Println("Failed to assert type for AnotherStruct")
        }
    }

    // 5. 尝试反序列化未注册的类型
    fmt.Println("\n--- Unmarshaling NonExistentType ---")
    _, err = registry.UnmarshalFromJSONString(jsonData1, "NonExistentType")
    if err != nil {
        fmt.Println("Error unmarshaling NonExistentType (expected):", err)
    }
}