Go语言中如何优雅地发现并注册接口实现类型

package registry

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

// 定义一个示例接口
type Handler interface {
    Handle(request string) string
}

// 定义注册表
var (
    handlerRegistry = make(map[string]reflect.Type)
    mu              sync.RWMutex
)

// RegisterHandler 用于注册 Handler 接口的实现类型
// 参数 v 必须是一个实现了 Handler 接口的类型实例（或零值），或者是一个指向该类型零值的指针
func RegisterHandler(name string, handlerType reflect.Type) error {
    if handlerType.Kind() != reflect.Struct && !(handlerType.Kind() == reflect.Ptr && handlerType.Elem().Kind() == reflect.Struct) {
        return fmt.Errorf("注册类型必须是结构体或结构体指针，但得到了 %s", handlerType.Kind())
    }

    // 检查类型是否实现了 Handler 接口
    var handlerInstance Handler
    if !handlerType.Implements(reflect.TypeOf(&handlerInstance).Elem()) {
        return fmt.Errorf("类型 %s 没有实现 registry.Handler 接口", handlerType.String())
    }

    mu.Lock()
    defer mu.Unlock()
    if _, exists := handlerRegistry[name]; exists {
        return fmt.Errorf("处理器名称 '%s' 已被注册", name)
    }
    handlerRegistry[name] = handlerType
    fmt.Printf("注册了处理器: %s (%s)\n", name, handlerType.String())
    return nil
}

// GetHandlerInstance 根据名称获取并创建一个 Handler 接口的实例
func GetHandlerInstance(name string) (Handler, error) {
    mu.RLock()
    defer mu.RUnlock()

    handlerType, ok := handlerRegistry[name]
    if !ok {
        return nil, fmt.Errorf("未找到名为 '%s' 的处理器", name)
    }

    // 创建实例
    // 如果注册的是结构体类型，需要创建结构体实例
    // 如果注册的是结构体指针类型，需要创建结构体实例并取地址
    var instance reflect.Value
    if handlerType.Kind() == reflect.Ptr {
        instance = reflect.New(handlerType.Elem())
    } else {
        instance = reflect.New(handlerType).Elem()
    }

    if handler, ok := instance.Interface().(Handler); ok {
        return handler, nil
    }
    return nil, fmt.Errorf("无法将类型 %s 转换为 Handler 接口", handlerType.String())
}

// ListRegisteredHandlers 返回所有已注册的处理器名称
func ListRegisteredHandlers() []string {
    mu.RLock()
    defer mu.RUnlock()
    names := make([]string, 0, len(handlerRegistry))
    for name := range handlerRegistry {
        names = append(names, name)
    }
    return names
}

package handlers

import (
    "fmt"
    "reflect"
    "your_module/registry" // 替换为你的模块路径
)

type SimpleHandler struct{}

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

// 在 init 函数中注册 SimpleHandler
func init() {
    if err := registry.RegisterHandler("simple", reflect.TypeOf(&SimpleHandler{})); err != nil {
        fmt.Printf("注册 SimpleHandler 失败: %v\n", err)
    }
}

package handlers

import (
    "fmt"
    "reflect"
    "your_module/registry" // 替换为你的模块路径
)

type AdvancedHandler struct {
    Config string
}

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

// 在 init 函数中注册 AdvancedHandler
func init() {
    if err := registry.RegisterHandler("advanced", reflect.TypeOf(&AdvancedHandler{})); err != nil {
        fmt.Printf("注册 AdvancedHandler 失败: %v\n", err)
    }
}

package main

import (
    "fmt"
    "your_module/handlers" // 导入包含 init 函数的包
    "your_module/registry" // 导入注册表包
)

func main() {
    // 确保导入了 handlers 包，其 init() 函数会被执行，从而注册处理器
    _ = handlers.SimpleHandler{} // 仅为确保导入，实际项目中可能不需要直接引用
    _ = handlers.AdvancedHandler{}

    fmt.Println("\n--- 已注册的处理器 ---")
    for _, name := range registry.ListRegisteredHandlers() {
        fmt.Printf("- %s\n", name)
    }

    fmt.Println("\n--- 获取并使用处理器 ---")

    // 获取 SimpleHandler 实例
    simpleHandler, err := registry.GetHandlerInstance("simple")
    if err != nil {
        fmt.Printf("获取 simple 处理器失败: %v\n", err)
    } else {
        fmt.Println(simpleHandler.Handle("hello"))
    }

    // 获取 AdvancedHandler 实例
    advancedHandler, err := registry.GetHandlerInstance("advanced")
    if err != nil {
        fmt.Printf("获取 advanced 处理器失败: %v\n", err)
    } else {
        // 对于 AdvancedHandler，如果需要配置，可以在获取后进行设置
        if ah, ok := advancedHandler.(*handlers.AdvancedHandler); ok {
            ah.Config = "CustomConfig"
        }
        fmt.Println(advancedHandler.Handle("world"))
    }

    // 尝试获取一个未注册的处理器
    _, err = registry.GetHandlerInstance("nonexistent")
    if err != nil {
        fmt.Printf("获取 nonexistent 处理器失败 (预期错误): %v\n", err)
    }
}

注册了处理器: simple (*your_module.handlers.SimpleHandler)
注册了处理器: advanced (*your_module.handlers.AdvancedHandler)

--- 已注册的处理器 ---
- simple
- advanced

--- 获取并使用处理器 ---
SimpleHandler processed request: hello
AdvancedHandler (Config: CustomConfig) processed request: world
获取 nonexistent 处理器失败 (预期错误): 未找到名为 'nonexistent' 的处理器