Go语言运行时反射：通过类型名称字符串获取reflect.Type的挑战与策略

package main

import (
    "fmt"
    "reflect"
)

// 定义一些示例结构体
type TaskA struct {
    ID   int
    Name string
}

type TaskB struct {
    Message string
    Value   float64
}

// 全局类型注册表
var typeRegistry = make(map[string]reflect.Type)
var zeroValueRegistry = make(map[string]interface{})

// RegisterType 用于注册类型
func RegisterType(obj interface{}) {
    t := reflect.TypeOf(obj)
    name := t.String() // 获取完整的类型名称，例如 "main.TaskA"
    typeRegistry[name] = t
    zeroValueRegistry[name] = reflect.Zero(t).Interface() // 存储零值，用于后续创建新实例
    fmt.Printf("Registered type: %s\n", name)
}

// GetTypeByName 从注册表中获取reflect.Type
func GetTypeByName(name string) (reflect.Type, bool) {
    t, ok := typeRegistry[name]
    return t, ok
}

// CreateNewInstanceByName 根据类型名称创建新的实例
func CreateNewInstanceByName(name string) (interface{}, error) {
    zeroVal, ok := zeroValueRegistry[name]
    if !ok {
        return nil, fmt.Errorf("type %s not registered", name)
    }
    // 获取类型
    t := reflect.TypeOf(zeroVal)
    // 创建一个新的零值实例
    newInstance := reflect.New(t).Elem().Interface()
    return newInstance, nil
}

func main() {
    // 注册所有需要动态查找的类型
    RegisterType(TaskA{})
    RegisterType(TaskB{})

    fmt.Println("\n--- 动态获取类型并创建实例 ---")

    // 尝试获取并创建TaskA的实例
    typeNameA := "main.TaskA"
    if t, ok := GetTypeByName(typeNameA); ok {
        fmt.Printf("Found type '%s': %v\n", typeNameA, t)
        if instance, err := CreateNewInstanceByName(typeNameA); err == nil {
            fmt.Printf("Created instance of %s: %v, type: %T\n", typeNameA, instance, instance)
            // 可以将interface{}断言回具体类型并使用
            if taskA, ok := instance.(TaskA); ok {
                taskA.ID = 101
                taskA.Name = "First Task"
                fmt.Printf("Populated TaskA: %+v\n", taskA)
            }
        } else {
            fmt.Printf("Failed to create instance of %s: %v\n", typeNameA, err)
        }
    } else {
        fmt.Printf("Type '%s' not found in registry.\n", typeNameA)
    }

    fmt.Println("\n--- 尝试获取未注册类型 ---")
    typeNameC := "main.UnknownType"
    if _, ok := GetTypeByName(typeNameC); !ok {
        fmt.Printf("Type '%s' not found as expected.\n", typeNameC)
    }
    if _, err := CreateNewInstanceByName(typeNameC); err != nil {
        fmt.Printf("Failed to create instance of '%s' as expected: %v\n", typeNameC, err)
    }
}

Registered type: main.TaskA
Registered type: main.TaskB

--- 动态获取类型并创建实例 ---
Found type 'main.TaskA': main.TaskA
Created instance of main.TaskA: {0 }, type: main.TaskA
Populated TaskA: {ID:101 Name:First Task}

--- 尝试获取未注册类型 ---
Type 'main.UnknownType' not found as expected.
Failed to create instance of 'main.UnknownType' as expected: type main.UnknownType not registered