在Go语言中通过字符串名称获取reflect.Type的策略与限制

package main

import (
    "fmt"
    "reflect"
)

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

type Product struct {
    SKU   string
    Price float64
}

// typeRegistry 是一个全局的类型注册表
// 键是类型的字符串名称，值是对应的 reflect.Type
var typeRegistry = make(map[string]reflect.Type)

// RegisterType 用于将一个类型注册到全局注册表中。
// 参数 obj 可以是该类型的一个零值实例或其指针。
// t.String() 会返回如 "main.User" 或 "main.Product" (包含包名)。
// 如果需要更简洁的名称（如仅 "User"），可以使用 t.Name()，但需注意不同包下可能存在同名类型。
func RegisterType(obj interface{}) {
    t := reflect.TypeOf(obj)
    // 通常我们注册指针类型，因为反射创建实例时通常需要返回指针
    // 如果注册的是非指针类型，例如 User{}，那么 t.String() 会是 "main.User"
    // 如果注册的是指针类型，例如 &User{}，那么 t.String() 会是 "*main.User"
    // 在本例中，我们注册指针类型，并在查找时也使用指针类型的名称。
    // 或者，更灵活的做法是注册非指针类型，并在需要时通过 reflect.PtrTo(t) 转换为指针类型。

    // 示例中我们注册的是指针类型，方便后续New创建实例
    // 所以传入的obj最好是零值指针，或者在内部处理成指针类型
    if t.Kind() != reflect.Ptr {
        t = reflect.PtrTo(t) // 确保注册的是指针类型，方便后续reflect.New
    }
    typeRegistry[t.String()] = t
    fmt.Printf("注册类型: %s -> %v\n", t.String(), t)
}

// GetTypeByName 从注册表中获取 reflect.Type。
// 返回的 reflect.Type 是指针类型，例如 *main.User。
func GetTypeByName(typeName string) (reflect.Type, bool) {
    t, ok := typeRegistry[typeName]
    return t, ok
}

func init() {
    // 在程序启动时注册所有需要反射的类型。
    // 注册时传入零值实例，RegisterType内部处理为指针类型
    RegisterType(User{})
    RegisterType(Product{})
}

func main() {
    // 尝试通过名称获取类型
    // 注意：这里的名称需要与 RegisterType 中 t.String() 返回的名称一致
    // 因为我们注册的是指针类型，所以这里查找的也是指针类型的字符串表示
    typeName1 := "*main.User" 
    if userPtrType, ok := GetTypeByName(typeName1); ok {
        fmt.Printf("成功获取类型 '%s': %v\n", typeName1, userPtrType)
        // 通过反射创建新实例。userPtrType 是 *main.User，所以不需要 .Elem()
        // reflect.New(userPtrType) 返回的是 reflect.Value，其底层是 *main.User
        newUserValue := reflect.New(userPtrType.Elem()) // userPtrType.Elem() 获取的是 main.User 类型
        newUser := newUserValue.Interface()
        fmt.Printf("创建新实例: %T, %v\n", newUser, newUser) // 此时 newUser 是 *main.User

        // 也可以直接使用 reflect.New(userPtrType.Elem()).Interface().(*User) 进行类型断言
        concreteUser := newUser.(*User)
        concreteUser.ID = 1
        concreteUser.Name = "Alice"
        fmt.Printf("设置字段后: %v\n", concreteUser)

    } else {
        fmt.Printf("无法获取类型 '%s'\n", typeName1)
    }

    fmt.Println("---")

    typeName2 := "*main.Product"
    if productPtrType, ok := GetTypeByName(typeName2); ok {
        fmt.Printf("成功获取类型 '%s': %v\n", typeName2, productPtrType)
        newProductValue := reflect.New(productPtrType.Elem())
        newProduct := newProductValue.Interface()
        fmt.Printf("创建新实例: %T, %v\n", newProduct, newProduct) // 此时 newProduct 是 *main.Product

        concreteProduct := newProduct.(*Product)
        concreteProduct.SKU = "P1001"
        concreteProduct.Price = 99.99
        fmt.Printf("设置字段后: %v\n", concreteProduct)

    } else {
        fmt.Printf("无法获取类型 '%s'\n", typeName2)
    }

    fmt.Println("---")

    typeName3 := "*main.NonExistentType"
    if _, ok := GetTypeByName(typeName3); !ok {
        fmt.Printf("无法获取类型 '%s' (符合预期)\n", typeName3)
    }
}