Go语言中通过字符串名称动态获取reflect.Type的策略与实践

package main

import (
    "fmt"
    "reflect"
    "sync" // 用于并发安全
)

// TypeRegistry 用于存储类型名称到reflect.Type的映射
// 使用sync.Map以支持并发安全地读写，或使用sync.RWMutex保护普通map
var TypeRegistry = sync.Map{}

// RegisterType 用于注册一个类型。
// 参数obj可以是该类型的一个零值实例或指针。
// 注册时使用的key是reflect.Type.String()的返回值，它通常包含包路径和类型名。
func RegisterType(obj interface{}) {
    t := reflect.TypeOf(obj)
    // reflect.Type.String() 返回格式如 "main.MyStruct" 或 "int"
    TypeRegistry.Store(t.String(), t)

    // 如果需要，也可以注册不带包路径的类型名（如果确保唯一性）
    // if t.Kind() == reflect.Struct || t.Kind() == reflect.Ptr {
    //  if t.Kind() == reflect.Ptr {
    //      t = t.Elem() // 如果是指针，获取其指向的元素类型
    //  }
    //  TypeRegistry.Store(t.Name(), t)
    // }
}

// GetTypeByName 从注册表中获取一个类型。
// 参数typeName应与注册时使用的key一致（通常是reflect.Type.String()的返回值）。
func GetTypeByName(typeName string) (reflect.Type, bool) {
    if val, ok := TypeRegistry.Load(typeName); ok {
        return val.(reflect.Type), true
    }
    return nil, false
}

// 示例结构体
type MyStruct struct {
    Name string
    Age  int
}

type AnotherStruct struct {
    ID   string
    Data []byte
}

func main() {
    // 1. 注册类型
    // 在程序启动或初始化阶段注册所有需要动态查找的类型
    RegisterType(MyStruct{})        // 注册MyStruct类型
    RegisterType(&AnotherStruct{})  // 也可以注册指针类型，reflect.TypeOf会得到*main.AnotherStruct
    RegisterType(int(0))            // 注册基本类型int
    RegisterType([]string{})        // 注册切片类型

    fmt.Println("已注册的类型:")
    TypeRegistry.Range(func(key, value interface{}) bool {
        fmt.Printf("- %s (Type: %v)\n", key, value)
        return true
    })

    // 2. 尝试获取类型并创建实例
    fmt.Println("\n--- 动态类型查找与创建 ---")

    // 查找并创建 MyStruct 实例
    typeName1 := "main.MyStruct" // 注意：结构体的完整类型名包含包路径
    if t, ok := GetTypeByName(typeName1); ok {
        fmt.Printf("找到类型 '%s': %v\n", typeName1, t)
        // 通过反射创建该类型的新实例（零值）
        // reflect.New(t) 返回一个指向新分配的零值的指针（reflect.Value）
        // .Elem() 获取指针指向的元素值
        newValue := reflect.New(t).Elem().Interface()
        fmt.Printf("创建新实例: %+v (类型: %T)\n", newValue, newValue)
    } else {
        fmt.Printf("类型 '%s' 未找到。\n", typeName1)
    }

    // 查找并创建 AnotherStruct 实例 (注意注册时是&AnotherStruct{}，所以类型名是*main.AnotherStruct)
    typeName2 := "*main.AnotherStruct"
    if t, ok := GetTypeByName(typeName2); ok {
        fmt.Printf("\n找到类型 '%s': %v\n", typeName2, t)
        newValue := reflect.New(t.Elem()).Elem().Interface() // 注意这里需要先.Elem()获取结构体类型再创建
        fmt.Printf("创建新实例: %+v (类型: %T)\n", newValue, newValue)
    } else {
        fmt.Printf("\n类型 '%s' 未找到。\n", typeName2)
    }

    // 查找基本类型 int
    typeName3 := "int"
    if t, ok := GetTypeByName(typeName3); ok {
        fmt.Printf("\n找到类型 '%s': %v\n", typeName3, t)
        newValue := reflect.New(t).Elem().Interface()
        fmt.Printf("创建新实例: %+v (类型: %T)\n", newValue, newValue)
    } else {
        fmt.Printf("\n类型 '%s' 未找到。\n", typeName3)
    }

    // 查找一个不存在的类型
    typeName4 := "main.NonExistentType"
    if _, ok := GetTypeByName(typeName4); !ok {
        fmt.Printf("\n类型 '%s' 未找到。\n", typeName4)
    }
}