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

package main

import (
    "fmt"
    "reflect"
)

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

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

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

// init函数用于注册类型
func init() {
    fmt.Println("Initializing type registry...")
    typeRegistry["MyStruct"] = reflect.TypeOf(MyStruct{})
    typeRegistry["AnotherStruct"] = reflect.TypeOf(AnotherStruct{})
    fmt.Println("Type registry initialized.")
}

// CreateInstanceFromString 根据类型名称字符串创建实例
func CreateInstanceFromString(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 实例
    instance1, err := CreateInstanceFromString("MyStruct")
    if err != nil {
        fmt.Println("Error creating instance:", err)
        return
    }
    // 类型断言并使用
    if myStruct, ok := instance1.(MyStruct); ok {
        myStruct.Name = "Alice"
        myStruct.Age = 30
        fmt.Printf("Created MyStruct: %+v (Type: %T)\n", myStruct, myStruct)
    }

    // 尝试创建 AnotherStruct 实例
    instance2, err := CreateInstanceFromString("AnotherStruct")
    if err != nil {
        fmt.Println("Error creating instance:", err)
        return
    }
    if anotherStruct, ok := instance2.(AnotherStruct); ok {
        anotherStruct.ID = "XYZ123"
        fmt.Printf("Created AnotherStruct: %+v (Type: %T)\n", anotherStruct, anotherStruct)
    }

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

package main

import (
    "fmt"
)

// 定义一个通用接口
type Shape interface {
    Area() float64
    String() string
}

// 实现圆形
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func (c Circle) String() string {
    return fmt.Sprintf("Circle with radius %.2f", c.Radius)
}

// 实现矩形
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) String() string {
    return fmt.Sprintf("Rectangle with width %.2f, height %.2f", r.Width, r.Height)
}

// 定义一个工厂函数类型
type ShapeFactory func() Shape

// 注册工厂函数的映射
var shapeFactories = make(map[string]ShapeFactory)

// 注册函数
func RegisterShape(name string, factory ShapeFactory) {
    shapeFactories[name] = factory
}

func init() {
    // 注册具体的形状工厂
    RegisterShape("Circle", func() Shape { return &Circle{} })
    RegisterShape("Rectangle", func() Shape { return &Rectangle{} })
}

// CreateShape 根据名称创建形状实例
func CreateShape(name string) (Shape, error) {
    if factory, ok := shapeFactories[name]; ok {
        return factory(), nil
    }
    return nil, fmt.Errorf("unknown shape type: %s", name)
}

func main() {
    circle, err := CreateShape("Circle")
    if err != nil {
        fmt.Println("Error creating circle:", err)
        return
    }
    circle.(*Circle).Radius = 5.0 // 类型断言后设置属性
    fmt.Println(circle.String(), "Area:", circle.Area())

    rectangle, err := CreateShape("Rectangle")
    if err != nil {
        fmt.Println("Error creating rectangle:", err)
        return
    }
    rect := rectangle.(*Rectangle) // 类型断言后设置属性
    rect.Width = 4.0
    rect.Height = 6.0
    fmt.Println(rectangle.String(), "Area:", rectangle.Area())

    _, err = CreateShape("Triangle")
    if err != nil {
        fmt.Println("Error creating triangle:", err)
    }
}

package main

import (
    "fmt"
)

type User struct {
    ID   int
    Name string
}

type Product struct {
    SKU  string
    Name string
}

// 注册创建函数的映射
var creatorRegistry = make(map[string]func() interface{})

func init() {
    creatorRegistry["User"] = func() interface{} { return &User{} }
    creatorRegistry["Product"] = func() interface{} { return &Product{} }
}

// CreateObject 根据名称创建对象
func CreateObject(name string) (interface{}, error) {
    if creator, ok := creatorRegistry[name]; ok {
        return creator(), nil
    }
    return nil, fmt.Errorf("no creator registered for type: %s", name)
}

func main() {
    userObj, err := CreateObject("User")
    if err != nil {
        fmt.Println("Error creating user:", err)
        return
    }
    if user, ok := userObj.(*User); ok { // 注意这里返回的是指针，需要断言为指针类型
        user.ID = 1
        user.Name = "John Doe"
        fmt.Printf("Created User: %+v (Type: %T)\n", user, user)
    }

    productObj, err := CreateObject("Product")
    if err != nil {
        fmt.Println("Error creating product:", err)
        return
    }
    if product, ok := productObj.(*Product); ok {
        product.SKU = "P001"
        product.Name = "Go Book"
        fmt.Printf("Created Product: %+v (Type: %T)\n", product, product)
    }

    _, err = CreateObject("Order")
    if err != nil {
        fmt.Println("Error creating order:", err)
    }
}