Go语言：通过字符串名称动态创建类型实例

package main

import (
    "fmt"
    "reflect"
)

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

// AnotherStruct 是另一个示例结构体
type AnotherStruct struct {
    ID string
}

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

func init() {
    // 在init函数中注册需要动态创建的类型
    typeRegistry["MyStruct"] = reflect.TypeOf(MyStruct{})
    typeRegistry["AnotherStruct"] = reflect.TypeOf(AnotherStruct{})
}

// CreateInstanceFromTypeName 根据类型名称字符串创建实例
func CreateInstanceFromTypeName(typeName string) (interface{}, error) {
    if typ, ok := typeRegistry[typeName]; ok {
        // reflect.New(typ) 返回一个指向新分配的零值的指针 (reflect.Value)
        // Elem() 解引用指针，得到实际的 reflect.Value
        // Interface() 将 reflect.Value 转换为 interface{}
        return reflect.New(typ).Elem().Interface(), nil
    }
    return nil, fmt.Errorf("type '%s' not found in registry", typeName)
}

func main() {
    // 尝试创建 MyStruct 实例
    myStructInstance, err := CreateInstanceFromTypeName("MyStruct")
    if err != nil {
        fmt.Println("Error creating MyStruct:", err)
    } else {
        // 类型断言将其转换为具体类型
        if s, ok := myStructInstance.(MyStruct); ok {
            fmt.Printf("Created MyStruct: %+v, Type: %T\n", s, s)
            // 可以修改其字段，但需要先将其转换为 reflect.Value 的可设置版本
            // 这种操作通常更复杂，此处仅演示创建
        }
    }

    // 尝试创建 AnotherStruct 实例
    anotherStructInstance, err := CreateInstanceFromTypeName("AnotherStruct")
    if err != nil {
        fmt.Println("Error creating AnotherStruct:", err)
    } else {
        if s, ok := anotherStructInstance.(AnotherStruct); ok {
            fmt.Printf("Created AnotherStruct: %+v, Type: %T\n", s, s)
        }
    }

    // 尝试创建不存在的类型实例
    _, err = CreateInstanceFromTypeName("NonExistentType")
    if err != nil {
        fmt.Println("Error creating NonExistentType:", err) // Expected error
    }
}

package main

import "fmt"

// Product 是一个接口，定义了所有可创建对象的通用行为
type Product interface {
    GetName() string
    DoSomething()
}

// ConcreteProductA 是 Product 的一个具体实现
type ConcreteProductA struct {
    Name string
}

func (p *ConcreteProductA) GetName() string { return p.Name }
func (p *ConcreteProductA) DoSomething()    { fmt.Println("Product A doing something.") }

// ConcreteProductB 是 Product 的另一个具体实现
type ConcreteProductB struct {
    ID int
}

func (p *ConcreteProductB) GetName() string { return fmt.Sprintf("Product B (ID: %d)", p.ID) }
func (p *ConcreteProductB) DoSomething()    { fmt.Println("Product B doing something else.") }

// FactoryFunc 是创建 Product 实例的函数类型
type FactoryFunc func() Product

var productFactories = make(map[string]FactoryFunc)

func init() {
    // 注册工厂函数
    productFactories["ProductA"] = func() Product { return &ConcreteProductA{Name: "Default A"} }
    productFactories["ProductB"] = func() Product { return &ConcreteProductB{ID: 0} }
}

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

func main() {
    pA, err := CreateProduct("ProductA")
    if err != nil {
        fmt.Println("Error creating ProductA:", err)
    } else {
        fmt.Printf("Created: %s, Type: %T\n", pA.GetName(), pA)
        pA.DoSomething()
    }

    pB, err := CreateProduct("ProductB")
    if err != nil {
        fmt.Println("Error creating ProductB:", err)
    } else {
        fmt.Printf("Created: %s, Type: %T\n", pB.GetName(), pB)
        pB.DoSomething()
    }

    _, err = CreateProduct("UnknownProduct")
    if err != nil {
        fmt.Println("Error creating UnknownProduct:", err)
    }
}

package main

import "fmt"

type ConfigA struct {
    Host string
    Port int
}

type ConfigB struct {
    Path string
    User string
}

var constructorRegistry = make(map[string]func() interface{})

func init() {
    // 注册构造函数
    constructorRegistry["ConfigA"] = func() interface{} { return &ConfigA{} }
    constructorRegistry["ConfigB"] = func() interface{} { return &ConfigB{} }
}

// NewInstanceByName 根据名称创建实例
func NewInstanceByName(name string) (interface{}, error) {
    if constructor, ok := constructorRegistry[name]; ok {
        return constructor(), nil
    }
    return nil, fmt.Errorf("constructor for '%s' not found", name)
}

func main() {
    configAInstance, err := NewInstanceByName("ConfigA")
    if err != nil {
        fmt.Println("Error creating ConfigA:", err)
    } else {
        if ca, ok := configAInstance.(*ConfigA); ok { // 注意这里需要类型断言为指针
            ca.Host = "localhost"
            ca.Port = 8080
            fmt.Printf("Created ConfigA: %+v, Type: %T\n", ca, ca)
        }
    }

    configBInstance, err := NewInstanceByName("ConfigB")
    if err != nil {
        fmt.Println("Error creating ConfigB:", err)
    } else {
        if cb, ok := configBInstance.(*ConfigB); ok {
            cb.Path = "/var/log"
            cb.User = "admin"
            fmt.Printf("Created ConfigB: %+v, Type: %T\n", cb, cb)
        }
    }
}