Go语言中通过字符串动态创建类型实例的实践指南

package main

import (
    "fmt"
    "reflect"
    "sync"
)

// Global registry for types
var (
    typeRegistry = make(map[string]reflect.Type)
    mu           sync.RWMutex // Protect access to typeRegistry
)

// RegisterType registers a type with the global registry.
// The parameter 't' should be an instance of the type to register (e.g., MyStruct{}).
func RegisterType(typeName string, t interface{}) {
    mu.Lock()
    defer mu.Unlock()
    typeRegistry[typeName] = reflect.TypeOf(t)
    fmt.Printf("Registered type: %s\n", typeName)
}

// CreateInstanceFromString creates a new instance of a registered type by its name.
func CreateInstanceFromString(typeName string) (interface{}, error) {
    mu.RLock()
    defer mu.RUnlock()

    typ, found := typeRegistry[typeName]
    if !found {
        return nil, fmt.Errorf("type '%s' not found in registry", typeName)
    }

    // reflect.New returns a Value representing a pointer to a new zero value for the type.
    // Elem() dereferences the pointer.
    // Interface() returns the Value's current value as an interface{}.
    return reflect.New(typ).Elem().Interface(), nil
}

// Define some example structs
type MyStruct struct {
    Name string
    ID   int
}

type AnotherStruct struct {
    Value float64
}

// init function to register types when the package is initialized
func init() {
    RegisterType("MyStruct", MyStruct{})
    RegisterType("AnotherStruct", AnotherStruct{})
}

func main() {
    fmt.Println("--- Using reflect for dynamic instantiation ---")

    // Create an instance of MyStruct
    instance1, err := CreateInstanceFromString("MyStruct")
    if err != nil {
        fmt.Println("Error creating MyStruct:", err)
        return
    }
    if s, ok := instance1.(MyStruct); ok {
        s.Name = "Reflected Instance 1"
        s.ID = 123
        fmt.Printf("Created MyStruct: %+v\n", s)
    } else {
        fmt.Println("Failed to assert type for MyStruct")
    }

    // Create an instance of AnotherStruct
    instance2, err := CreateInstanceFromString("AnotherStruct")
    if err != nil {
        fmt.Println("Error creating AnotherStruct:", err)
        return
    }
    if as, ok := instance2.(AnotherStruct); ok {
        as.Value = 3.14
        fmt.Printf("Created AnotherStruct: %+v\n", as)
    } else {
        fmt.Println("Failed to assert type for AnotherStruct")
    }

    // Try to create an unregistered type
    _, err = CreateInstanceFromString("NonExistentStruct")
    if err != nil {
        fmt.Println("Expected error for NonExistentStruct:", err)
    }
}

package main

import "fmt"

// Define an interface for objects that can be created
type Product interface {
    Describe() string
}

// Implementations of the Product interface
type ConcreteProductA struct {
    Name string
}

func (p *ConcreteProductA) Describe() string {
    return fmt.Sprintf("This is Product A: %s", p.Name)
}

type ConcreteProductB struct {
    ID int
}

func (p *ConcreteProductB) Describe() string {
    return fmt.Sprintf("This is Product B with ID: %d", p.ID)
}

// Factory function type
type ProductFactory func() Product

// Global registry for factories
var productFactories = make(map[string]ProductFactory)

// RegisterFactory registers a factory function for a given product type.
func RegisterFactory(typeName string, factory ProductFactory) {
    productFactories[typeName] = factory
    fmt.Printf("Registered factory for: %s\n", typeName)
}

// GetProduct creates a product instance using its registered factory.
func GetProduct(typeName string) (Product, error) {
    factory, found := productFactories[typeName]
    if !found {
        return nil, fmt.Errorf("factory for product type '%s' not found", typeName)
    }
    return factory(), nil
}

func init() {
    // Register concrete product factories
    RegisterFactory("ProductA", func() Product { return &ConcreteProductA{Name: "Default A"} })
    RegisterFactory("ProductB", func() Product { return &ConcreteProductB{ID: 0} })
}

func main() {
    fmt.Println("\n--- Using Factory Method Pattern ---")

    productA, err := GetProduct("ProductA")
    if err != nil {
        fmt.Println("Error getting ProductA:", err)
        return
    }
    fmt.Println(productA.Describe())
    // You can then cast it back if you need specific fields
    if pa, ok := productA.(*ConcreteProductA); ok {
        pa.Name = "Custom A"
        fmt.Println(pa.Describe())
    }


    productB, err := GetProduct("ProductB")
    if err != nil {
        fmt.Println("Error getting ProductB:", err)
        return
    }
    fmt.Println(productB.Describe())
    if pb, ok := productB.(*ConcreteProductB); ok {
        pb.ID = 456
        fmt.Println(pb.Describe())
    }

    _, err = GetProduct("UnknownProduct")
    if err != nil {
        fmt.Println("Expected error for UnknownProduct:", err)
    }
}

package main

import "fmt"

// Global registry for creation functions
var creationFuncs = make(map[string]func() interface{})

// RegisterCreator registers a function that creates an instance of a type.
func RegisterCreator(typeName string, creator func() interface{}) {
    creationFuncs[typeName] = creator
    fmt.Printf("Registered creator for: %s\n", typeName)
}

// CreateInstanceFromCreator creates an instance using its registered creator function.
func CreateInstanceFromCreator(typeName string) (interface{}, error) {
    creator, found := creationFuncs[typeName]
    if !found {
        return nil, fmt.Errorf("creator for type '%s' not found", typeName)
    }
    return creator(), nil
}

// Example structs (can be the same as in reflect example)
type Widget struct {
    Size string
}

type Gadget struct {
    Weight float64
}

func init() {
    RegisterCreator("Widget", func() interface{} { return &Widget{Size: "Medium"} })
    RegisterCreator("Gadget", func() interface{} { return &Gadget{Weight: 1.5} })
}

func main() {
    fmt.Println("\n--- Using Function Map for dynamic instantiation ---")

    widgetInstance, err := CreateInstanceFromCreator("Widget")
    if err != nil {
        fmt.Println("Error creating Widget:", err)
        return
    }
    if w, ok := widgetInstance.(*Widget); ok {
        fmt.Printf("Created Widget: %+v\n", w)
        w.Size = "Large"
        fmt.Printf("Modified Widget: %+v\n", w)
    }

    gadgetInstance, err := CreateInstanceFromCreator("Gadget")
    if err != nil {
        fmt.Println("Error creating Gadget:", err)
        return
    }
    if g, ok := gadgetInstance.(*Gadget); ok {
        fmt.Printf("Created Gadget: %+v\n", g)
    }

    _, err = CreateInstanceFromCreator("UnknownItem")
    if err != nil {
        fmt.Println("Expected error for UnknownItem:", err)
    }
}