Go语言中通过字符串动态实例化类型：反射与工厂模式

package main

import (
    "fmt"
    "reflect"
)

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

type AnotherStruct struct {
    ID   string
    Desc string
}

// 全局类型注册表
var registeredTypes = make(map[string]reflect.Type)

// init 函数用于注册类型
func init() {
    fmt.Println("Registering types...")
    RegisterType("MyStruct", MyStruct{})
    RegisterType("AnotherStruct", AnotherStruct{})
    fmt.Println("Types registered:", registeredTypes)
}

// RegisterType 辅助函数，用于注册类型
func RegisterType(name string, obj interface{}) {
    t := reflect.TypeOf(obj)
    // 如果传入的是指针，则获取其指向的类型
    if t.Kind() == reflect.Ptr {
        t = t.Elem()
    }
    registeredTypes[name] = t
}

// CreateInstanceFromString 根据类型名称字符串创建实例
func CreateInstanceFromString(typeName string) (interface{}, error) {
    if t, ok := registeredTypes[typeName]; ok {
        // reflect.New 返回一个指向新零值的指针的reflect.Value
        // 例如，对于MyStruct，它返回*MyStruct的reflect.Value
        newValue := reflect.New(t)
        // Elem() 解引用指针，得到实际的结构体值
        // Interface() 将reflect.Value转换为interface{}
        return newValue.Elem().Interface(), nil
    }
    return nil, fmt.Errorf("type '%s' not registered", typeName)
}

func main() {
    // 尝试创建 MyStruct 实例
    myStructInstance, err := CreateInstanceFromString("MyStruct")
    if err != nil {
        fmt.Println("Error creating MyStruct:", err)
        return
    }
    if ms, ok := myStructInstance.(MyStruct); ok {
        ms.Name = "Alice"
        ms.Age = 30
        fmt.Printf("Created MyStruct: %+v (Type: %T)\n", ms, ms)
    } else {
        fmt.Printf("Unexpected type for MyStruct: %T\n", myStructInstance)
    }

    // 尝试创建 AnotherStruct 实例
    anotherStructInstance, err := CreateInstanceFromString("AnotherStruct")
    if err != nil {
        fmt.Println("Error creating AnotherStruct:", err)
        return
    }
    if as, ok := anotherStructInstance.(AnotherStruct); ok {
        as.ID = "A001"
        as.Desc = "This is another struct"
        fmt.Printf("Created AnotherStruct: %+v (Type: %T)\n", as, as)
    } else {
        fmt.Printf("Unexpected type for AnotherStruct: %T\n", anotherStructInstance)
    }

    // 尝试创建未注册的类型
    _, err = CreateInstanceFromString("UnknownStruct")
    if err != nil {
        fmt.Println("Error creating UnknownStruct:", err)
    }
}

Registering types...
Types registered: map[AnotherStruct]main.AnotherStruct MyStruct]main.MyStruct]
Created MyStruct: {Name:Alice Age:30} (Type: main.MyStruct)
Created AnotherStruct: {ID:A001 Desc:This is another struct} (Type: main.AnotherStruct)
Error creating UnknownStruct: type 'UnknownStruct' not registered

package main

import (
    "fmt"
)

// 定义一些示例结构体
type ProductA struct {
    Name  string
    Price float64
}

type ProductB struct {
    ID   string
    Code int
}

// 全局工厂函数注册表
var productFactories = make(map[string]func() interface{})

// init 函数用于注册工厂函数
func init() {
    fmt.Println("Registering product factories...")
    RegisterProductFactory("ProductA", func() interface{} { return ProductA{} })
    RegisterProductFactory("ProductB", func() interface{} { return ProductB{} })
    fmt.Println("Factories registered:", productFactories)
}

// RegisterProductFactory 辅助函数，用于注册工厂函数
func RegisterProductFactory(name string, factory func() interface{}) {
    productFactories[name] = factory
}

// CreateProductFromString 根据产品名称字符串创建实例
func CreateProductFromString(productName string) (interface{}, error) {
    if factory, ok := productFactories[productName]; ok {
        return factory(), nil
    }
    return nil, fmt.Errorf("product factory for '%s' not registered", productName)
}

func main() {
    // 尝试创建 ProductA 实例
    productAInstance, err := CreateProductFromString("ProductA")
    if err != nil {
        fmt.Println("Error creating ProductA:", err)
        return
    }
    if pa, ok := productAInstance.(ProductA); ok {
        pa.Name = "Laptop"
        pa.Price = 1200.0
        fmt.Printf("Created ProductA: %+v (Type: %T)\n", pa, pa)
    } else {
        fmt.Printf("Unexpected type for ProductA: %T\n", productAInstance)
    }

    // 尝试创建 ProductB 实例
    productBInstance, err := CreateProductFromString("ProductB")
    if err != nil {
        fmt.Println("Error creating ProductB:", err)
        return
    }
    if pb, ok := productBInstance.(ProductB); ok {
        pb.ID = "PB001"
        pb.Code = 12345
        fmt.Printf("Created ProductB: %+v (Type: %T)\n", pb, pb)
    } else {
        fmt.Printf("Unexpected type for ProductB: %T\n", productBInstance)
    }

    // 尝试创建未注册的产品
    _, err = CreateProductFromString("UnknownProduct")
    if err != nil {
        fmt.Println("Error creating UnknownProduct:", err)
    }
}

Registering product factories...
Factories registered: map[ProductA]0x1092e00 ProductB]0x1092e00]
Created ProductA: {Name:Laptop Price:1200} (Type: main.ProductA)
Created ProductB: {ID:PB001 Code:12345} (Type: main.ProductB)
Error creating UnknownProduct: product factory for 'UnknownProduct' not registered