Go语言中接口实现类型的运行时发现与注册机制

package main

import (
    "fmt"
    "net/http"
    "sync"
)

// HandlerRegistry 是一个用于存储和检索 http.Handler 实现的注册器。
type HandlerRegistry struct {
    mu       sync.RWMutex
    handlers map[string]http.Handler
}

// NewHandlerRegistry 创建一个新的 HandlerRegistry 实例。
func NewHandlerRegistry() *HandlerRegistry {
    return &HandlerRegistry{
        handlers: make(map[string]http.Handler),
    }
}

// RegisterHandler 注册一个 http.Handler 实现。
// name 参数用于唯一标识该处理器。
func (r *HandlerRegistry) RegisterHandler(name string, handler http.Handler) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    if _, exists := r.handlers[name]; exists {
        return fmt.Errorf("handler with name '%s' already registered", name)
    }
    r.handlers[name] = handler
    fmt.Printf("Registered handler: %s\n", name)
    return nil
}

// GetHandler 根据名称获取一个 http.Handler 实现。
func (r *HandlerRegistry) GetHandler(name string) (http.Handler, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    handler, ok := r.handlers[name]
    if !ok {
        return nil, fmt.Errorf("handler with name '%s' not found", name)
    }
    return handler, nil
}

// GetAllHandlers 返回所有已注册的处理器。
func (r *HandlerRegistry) GetAllHandlers() map[string]http.Handler {
    r.mu.RLock()
    defer r.mu.RUnlock()
    // 返回一个副本，避免外部修改内部map
    copyMap := make(map[string]http.Handler)
    for k, v := range r.handlers {
        copyMap[k] = v
    }
    return copyMap
}

// 全局唯一的注册器实例
var globalHandlerRegistry = NewHandlerRegistry()

// GetGlobalHandlerRegistry 提供对全局注册器的访问
func GetGlobalHandlerRegistry() *HandlerRegistry {
    return globalHandlerRegistry
}

package v1

import (
    "fmt"
    "net/http"
    "runtime_discovery_tutorial" // 假设你的主模块名为 runtime_discovery_tutorial
)

// MyHandler 是一个 http.Handler 的实现
type MyHandler struct {
    Message string
}

func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from MyHandler: %s\n", h.Message)
}

// init 函数会在包被导入时自动执行
func init() {
    // 注册 MyHandler
    err := runtime_discovery_tutorial.GetGlobalHandlerRegistry().RegisterHandler("myHandler", &MyHandler{Message: "Version 1"})
    if err != nil {
        fmt.Printf("Error registering myHandler: %v\n", err)
    }
}

package v1

import (
    "fmt"
    "net/http"
    "runtime_discovery_tutorial"
)

// AnotherHandler 是另一个 http.Handler 的实现
type AnotherHandler struct{}

func (h *AnotherHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "This is AnotherHandler!\n")
}

func init() {
    // 注册 AnotherHandler
    err := runtime_discovery_tutorial.GetGlobalHandlerRegistry().RegisterHandler("anotherHandler", &AnotherHandler{})
    if err != nil {
        fmt.Printf("Error registering anotherHandler: %v\n", err)
    }
}

package main

import (
    "fmt"
    "log"
    "net/http"

    _ "runtime_discovery_tutorial/api/v1" // 导入包以触发其init()函数
)

func main() {
    registry := GetGlobalHandlerRegistry()

    fmt.Println("\n--- Listing all registered handlers ---")
    allHandlers := registry.GetAllHandlers()
    for name, handler := range allHandlers {
        fmt.Printf("Found handler: '%s', Type: %T\n", name, handler)
    }

    fmt.Println("\n--- Retrieving and using specific handlers ---")
    // 获取并使用 myHandler
    myHandler, err := registry.GetHandler("myHandler")
    if err != nil {
        log.Fatalf("Failed to get myHandler: %v", err)
    }
    // 模拟一个 HTTP 请求来测试 handler
    fmt.Print("Testing myHandler: ")
    myHandler.ServeHTTP(&mockResponseWriter{}, nil) // 使用一个模拟的 ResponseWriter

    // 获取并使用 anotherHandler
    anotherHandler, err := registry.GetHandler("anotherHandler")
    if err != nil {
        log.Fatalf("Failed to get anotherHandler: %v", err)
    }
    fmt.Print("Testing anotherHandler: ")
    anotherHandler.ServeHTTP(&mockResponseWriter{}, nil)

    // 尝试获取一个不存在的 handler
    _, err = registry.GetHandler("nonExistentHandler")
    if err != nil {
        fmt.Printf("Expected error for nonExistentHandler: %v\n", err)
    }

    // 实际应用中，你可能会启动一个HTTP服务器
    // http.Handle("/my", myHandler)
    // http.Handle("/another", anotherHandler)
    // log.Fatal(http.ListenAndServe(":8080", nil))
}

// mockResponseWriter 是一个简单的 http.ResponseWriter 模拟，用于示例输出
type mockResponseWriter struct{}

func (m *mockResponseWriter) Header() http.Header {
    return http.Header{}
}

func (m *mockResponseWriter) Write(bytes []byte) (int, error) {
    fmt.Println(string(bytes))
    return len(bytes), nil
}

func (m *mockResponseWriter) WriteHeader(statusCode int) {}

Registered handler: myHandler
Registered handler: anotherHandler

--- Listing all registered handlers ---
Found handler: 'myHandler', Type: *v1.MyHandler
Found handler: 'anotherHandler', Type: *v1.AnotherHandler

--- Retrieving and using specific handlers ---
Testing myHandler: Hello from MyHandler: Version 1

Testing anotherHandler: This is AnotherHandler!

Expected error for nonExistentHandler: handler with name 'nonExistentHandler' not found