Go语言中基于字符串动态创建类型实例的策略

package main

import (
    "encoding/json"
    "fmt"
)

// ActionHandler 定义了所有动作必须实现的行为：执行和创建新实例
type ActionHandler interface {
    Exec()
    New() ActionHandler
}

// mActions 是一个全局映射，用于存储动作的零值实例，键为动作名称
var mActions = make(map[string]ActionHandler)

// aExit 是一个具体的动作类型，表示退出程序
type aExit struct{}

// Exec 实现了 aExit 的执行逻辑
func (s *aExit) Exec() { fmt.Println("Good bye") }

// New 实现了 aExit 的新实例创建逻辑
func (s *aExit) New() ActionHandler { return new(aExit) }

// init 函数用于注册 aExit 类型到 mActions
func init() {
    var a *aExit // 使用零值指针注册
    mActions[`exit`] = a
}

// aSay 是另一个具体的动作类型，表示说一句话
type aSay struct {
    To  string
    Msg string
}

// Exec 实现了 aSay 的执行逻辑
func (s *aSay) Exec() { fmt.Println(`You say, "` + s.Msg + `" to ` + s.To) }

// New 实现了 aSay 的新实例创建逻辑
func (s *aSay) New() ActionHandler { return new(aSay) }

// init 函数用于注册 aSay 类型到 mActions
func init() {
    var a *aSay // 使用零值指针注册
    mActions[`say`] = a
}

// inHandler 模拟一个输入处理器，根据动作名称和JSON数据执行操作
func inHandler(action string, data []byte) {
    // 从映射中获取零值实例，并调用其New()方法创建新的具体实例
    actionInstance := mActions[action].New()
    // 如果需要，可以将JSON数据反序列化到新实例中
    json.Unmarshal(data, &actionInstance)
    actionInstance.Exec()
}

func main() {
    inHandler(`say`, []byte(`{"To":"Sonia","Msg":"Please help me!"}`))
    inHandler(`exit`, []byte(`{}`))
}

package main

import (
    "fmt"
    "reflect"
)

type ta struct {
    A int
}
type tb struct {
    B float64
}
type tc struct {
    C string
}

// mTypes 是一个全局映射，用于存储类型名称与 reflect.Type 的关联
var mTypes map[string]reflect.Type = make(map[string]reflect.Type)

// init 函数用于注册各种类型到 mTypes
func init() {
    var a ta
    mTypes[`ta`] = reflect.TypeOf(a)
    var b tb
    mTypes[`tb`] = reflect.TypeOf(b)
    var c tc
    mTypes[`tc`] = reflect.TypeOf(c) // 注意：这里原示例是ta，已更正为tc
}

// MagicVarFunc 根据字符串名称动态创建对应类型的零值实例
func MagicVarFunc(typeName string) interface{} {
    typ, ok := mTypes[typeName]
    if !ok {
        fmt.Printf("Error: Type '%s' not registered.\n", typeName)
        return nil
    }
    // reflect.Zero(typ) 返回该类型的零值，然后通过 .Interface() 转换为 interface{}
    return reflect.Zero(typ).Interface()
}

func main() {
    // 动态创建 ta 类型的零值实例
    tA := "ta"
    vA := MagicVarFunc(tA)
    if vA != nil {
        fmt.Printf("Created type: %T, value: %+v\n", vA, vA)
        // 需要进行类型断言才能访问具体字段
        if instance, ok := vA.(ta); ok {
            instance.A = 10
            fmt.Printf("Modified instance: %+v\n", instance)
        }
    }

    // 动态创建 tb 类型的零值实例
    tB := "tb"
    vB := MagicVarFunc(tB)
    if vB != nil {
        fmt.Printf("Created type: %T, value: %+v\n", vB, vB)
        // 需要进行类型断言才能访问具体字段
        if instance, ok := vB.(tb); ok {
            instance.B = 8.3
            fmt.Printf("Modified instance: %+v\n", instance)
        }
    }

    // 动态创建 tc 类型的零值实例
    tC := "tc"
    vC := MagicVarFunc(tC)
    if vC != nil {
        fmt.Printf("Created type: %T, value: %+v\n", vC, vC)
        // 需要进行类型断言才能访问具体字段
        if instance, ok := vC.(tc); ok {
            instance.C = "hello"
            fmt.Printf("Modified instance: %+v\n", instance)
        }
    }

    // 尝试创建未注册的类型
    tUnknown := "tUnknown"
    vUnknown := MagicVarFunc(tUnknown)
    fmt.Printf("Created type: %T, value: %+v\n", vUnknown, vUnknown)
}

func MagicVarFuncPtr(typeName string) interface{} {
    typ, ok := mTypes[typeName]
    if !ok {
        fmt.Printf("Error: Type '%s' not registered.\n", typeName)
        return nil
    }
    // reflect.New(typ) 返回一个 Value 类型，代表指向新分配的零值的指针
    // 调用 .Interface() 获取 interface{} 类型的指针
    return reflect.New(typ).Interface()
}

func mainPtr() {
    tB := "tb"
    vB_ptr := MagicVarFuncPtr(tB) // 返回 *tb 类型的 interface{}
    if vB_ptr != nil {
        fmt.Printf("Created pointer type: %T, value: %+v\n", vB_ptr, vB_ptr)
        // 需要进行类型断言，并解引用才能访问具体字段
        if instancePtr, ok := vB_ptr.(*tb); ok {
            instancePtr.B = 8.3
            fmt.Printf("Modified instance via pointer: %+v\n", *instancePtr)
        }
    }
}