Go语言包内接口实现类型动态发现：反射的局限与注册模式

package main

import (
    "fmt"
    "sync"
)

// 定义一个自定义接口
type MyHandler interface {
    Handle(request string) string
    GetName() string
}

// 注册表，存储构造函数以便按需创建实例
// 使用 sync.Map 或读写锁以确保并发安全，如果注册发生在运行时
var registeredHandlers = struct {
    sync.RWMutex
    m map[string]func() MyHandler
}{
    m: make(map[string]func() MyHandler),
}

// RegisterHandler 注册一个MyHandler的构造函数
func RegisterHandler(name string, constructor func() MyHandler) {
    registeredHandlers.Lock()
    defer registeredHandlers.Unlock()
    if _, exists := registeredHandlers.m[name]; exists {
        panic(fmt.Sprintf("handler %s already registered", name))
    }
    registeredHandlers.m[name] = constructor
    fmt.Printf("Registered handler: %s\n", name)
}

// GetHandler 获取指定名称的MyHandler实例
func GetHandler(name string) (MyHandler, bool) {
    registeredHandlers.RLock()
    defer registeredHandlers.RUnlock()
    constructor, ok := registeredHandlers.m[name]
    if !ok {
        return nil, false
    }
    return constructor(), true // 调用构造函数创建新实例
}

// GetAllHandlerNames 获取所有已注册的处理器名称
func GetAllHandlerNames() []string {
    registeredHandlers.RLock()
    defer registeredHandlers.RUnlock()
    names := make([]string, 0, len(registeredHandlers.m))
    for name := range registeredHandlers.m {
        names = append(names, name)
    }
    return names
}

// --- 以下是实现MyHandler接口的类型 ---

// SpecificHandler 是MyHandler的一个实现
type SpecificHandler struct {
    ID string
}

func (s *SpecificHandler) Handle(request string) string {
    return fmt.Sprintf("SpecificHandler %s handled request: %s", s.ID, request)
}

func (s *SpecificHandler) GetName() string {
    return "specific_handler"
}

// 在init函数中注册SpecificHandler
func init() {
    RegisterHandler("specific_handler", func() MyHandler {
        return &SpecificHandler{ID: "ABC-123"}
    })
}

// AnotherHandler 是MyHandler的另一个实现
type AnotherHandler struct {
    Version string
}

func (a *AnotherHandler) Handle(request string) string {
    return fmt.Sprintf("AnotherHandler %s processed request: %s", a.Version, request)
}

func (a *AnotherHandler) GetName() string {
    return "another_handler"
}

// 在init函数中注册AnotherHandler
func init() {
    RegisterHandler("another_handler", func() MyHandler {
        return &AnotherHandler{Version: "v2.0"}
    })
}

func main() {
    fmt.Println("\n--- Discovering and Using Handlers ---")

    // 获取所有注册的处理器名称
    names := GetAllHandlerNames()
    fmt.Printf("All registered handler names: %v\n", names)

    // 通过名称获取并使用处理器
    if handler, ok := GetHandler("specific_handler"); ok {
        fmt.Printf("Using '%s': %s\n", handler.GetName(), handler.Handle("data_request_1"))
    } else {
        fmt.Println("Handler 'specific_handler' not found.")
    }

    if handler, ok := GetHandler("another_handler"); ok {
        fmt.Printf("Using '%s': %s\n", handler.GetName(), handler.Handle("data_request_2"))
    } else {
        fmt.Println("Handler 'another_handler' not found.")
    }

    if _, ok := GetHandler("non_existent_handler"); !ok {
        fmt.Println("Handler 'non_existent_handler' not found, as expected.")
    }
}