Go语言中通过字符串名称创建结构体实例的反射实践

package main

import (
    "fmt"
    "reflect"
)

type MyStruct struct {
    A int
    B string
}

type AnotherStruct struct {
    X float64
    Y bool
}

var typeRegistry = make(map[string]reflect.Type)

func init() {
    // 收集所有需要注册的结构体实例
    // 使用interface{}类型作为容器，方便遍历
    typesToRegister := []interface{}{
        MyStruct{},      // 注册MyStruct的零值
        AnotherStruct{}, // 注册AnotherStruct的零值
    }

    for _, v := range typesToRegister {
        // fmt.Sprintf("%T", v) 可以获取带包路径的类型名称，例如 "main.MyStruct"
        // 如果结构体在其他包，则会是 "pkgname.MyStruct"
        typeName := fmt.Sprintf("%T", v)
        typeRegistry[typeName] = reflect.TypeOf(v)
        fmt.Printf("Registered type: %s\n", typeName)
    }
}

// makeInstance 根据类型名称字符串创建并返回一个结构体实例
// 返回类型为interface{}，需要调用者进行类型断言
func makeInstance(name string) (interface{}, error) {
    typ, ok := typeRegistry[name]
    if !ok {
        return nil, fmt.Errorf("type %s not found in registry", name)
    }

    // reflect.New(typ) 返回一个指向新分配的零值类型的指针（reflect.Value类型）
    // 例如，对于MyStruct，它返回的是 *MyStruct 的 reflect.Value
    ptrValue := reflect.New(typ)

    // .Elem() 方法解引用指针，得到实际的结构体值（reflect.Value类型）
    // 例如，对于 *MyStruct 的 reflect.Value，.Elem() 返回 MyStruct 的 reflect.Value
    structValue := ptrValue.Elem()

    // .Interface() 方法将 reflect.Value 转换回 Go 的 interface{} 类型
    return structValue.Interface(), nil
}

package main

import (
    "fmt"
    "reflect"
)

// MyStruct 定义一个示例结构体
type MyStruct struct {
    A int
    B string
}

// AnotherStruct 定义另一个示例结构体
type AnotherStruct struct {
    X float64
    Y bool
}

// typeRegistry 用于存储结构体名称到其reflect.Type的映射
var typeRegistry = make(map[string]reflect.Type)

func init() {
    // 在程序启动时注册所有需要动态实例化的结构体
    typesToRegister := []interface{}{
        MyStruct{},
        AnotherStruct{},
    }

    for _, v := range typesToRegister {
        typeName := fmt.Sprintf("%T", v) // 获取带包路径的类型名称
        typeRegistry[typeName] = reflect.TypeOf(v)
        fmt.Printf("Registered type: %s\n", typeName)
    }
}

// makeInstance 根据类型名称字符串创建并返回一个结构体实例
func makeInstance(name string) (interface{}, error) {
    typ, ok := typeRegistry[name]
    if !ok {
        return nil, fmt.Errorf("type %s not found in registry", name)
    }

    // reflect.New(typ) 创建一个指向该类型零值的指针的reflect.Value
    // .Elem() 解引用该指针，得到实际的结构体值的reflect.Value
    structValue := reflect.New(typ).Elem()

    // .Interface() 将reflect.Value转换回Go的interface{}类型
    return structValue.Interface(), nil
}

func main() {
    fmt.Println("\n--- Creating instances dynamically ---")

    // 尝试创建 MyStruct 实例
    instance1, err := makeInstance("main.MyStruct")
    if err != nil {
        fmt.Println("Error creating MyStruct:", err)
    } else {
        // 类型断言，将interface{}转换为具体的MyStruct类型
        if myStruct, ok := instance1.(MyStruct); ok {
            myStruct.A = 100
            myStruct.B = "Hello from dynamic instance"
            fmt.Printf("Created MyStruct: %+v (Type: %T)\n", myStruct, myStruct)
        } else {
            fmt.Printf("Type assertion failed for MyStruct: %T\n", instance1)
        }
    }

    // 尝试创建 AnotherStruct 实例
    instance2, err := makeInstance("main.AnotherStruct")
    if err != nil {
        fmt.Println("Error creating AnotherStruct:", err)
    } else {
        if anotherStruct, ok := instance2.(AnotherStruct); ok {
            anotherStruct.X = 3.14
            anotherStruct.Y = true
            fmt.Printf("Created AnotherStruct: %+v (Type: %T)\n", anotherStruct, anotherStruct)
        } else {
            fmt.Printf("Type assertion failed for AnotherStruct: %T\n", instance2)
        }
    }

    // 尝试创建不存在的类型实例
    _, err = makeInstance("NonExistentStruct")
    if err != nil {
        fmt.Println("Attempt to create NonExistentStruct:", err)
    }
}

Registered type: main.MyStruct
Registered type: main.AnotherStruct

--- Creating instances dynamically ---
Created MyStruct: {A:100 B:Hello from dynamic instance} (Type: main.MyStruct)
Created AnotherStruct: {X:3.14 Y:true} (Type: main.AnotherStruct)
Attempt to create NonExistentStruct: type NonExistentStruct not found in registry