Golang动态注册处理器的实现方法

一种常见的动态注册处理器模式是使用中间件或包装函数来控制处理器的启用状态。以下是一个示例实现：

type RouteConfig struct {
    Path    string
    Enabled bool
    Handler string
}

type HandlerManager struct {
    handlers map[string]http.HandlerFunc
    config   []RouteConfig
}

func NewHandlerManager(config []RouteConfig) *HandlerManager {
    hm := &HandlerManager{
        handlers: make(map[string]http.HandlerFunc),
        config:   config,
    }
    
    // 注册所有处理器
    hm.handlers["a"] = handlerA
    hm.handlers["b"] = handlerB
    hm.handlers["c"] = handlerC
    
    return hm
}

func (hm *HandlerManager) RegisterRoutes(mux *http.ServeMux) {
    for _, route := range hm.config {
        if !route.Enabled {
            continue
        }
        
        handler, exists := hm.handlers[route.Handler]
        if !exists {
            continue
        }
        
        // 可选：添加中间件包装
        wrappedHandler := hm.wrapHandler(handler, route)
        mux.Handle(route.Path, wrappedHandler)
    }
}

func (hm *HandlerManager) wrapHandler(h http.HandlerFunc, route RouteConfig) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 这里可以添加通用的中间件逻辑
        // 例如：日志记录、认证、指标收集等
        h(w, r)
    }
}

// 使用示例
func main() {
    config := []RouteConfig{
        {Path: "/api/a", Enabled: true, Handler: "a"},
        {Path: "/api/b", Enabled: false, Handler: "b"},
        {Path: "/api/c", Enabled: true, Handler: "c"},
    }
    
    hm := NewHandlerManager(config)
    mux := http.NewServeMux()
    hm.RegisterRoutes(mux)
    
    http.ListenAndServe(":8080", mux)
}

另一种更灵活的方式是使用函数注册：

type Route struct {
    Path    string
    Handler http.HandlerFunc
    Enabled bool
}

func RegisterDynamicRoutes(mux *http.ServeMux, routes []Route) {
    for _, route := range routes {
        if route.Enabled {
            mux.Handle(route.Path, route.Handler)
        }
    }
}

// 使用闭包动态创建处理器
func createHandler(name string) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Handler %s is serving", name)
    }
}

func main() {
    mux := http.NewServeMux()
    
    routes := []Route{
        {Path: "/a", Handler: createHandler("a"), Enabled: true},
        {Path: "/b", Handler: createHandler("b"), Enabled: false},
        {Path: "/c", Handler: createHandler("c"), Enabled: true},
    }
    
    RegisterDynamicRoutes(mux, routes)
    http.ListenAndServe(":8080", mux)
}

如果需要更细粒度的控制，可以使用条件注册模式：

type HandlerRegistry struct {
    mu       sync.RWMutex
    handlers map[string]http.HandlerFunc
    enabled  map[string]bool
}

func (r *HandlerRegistry) Register(name string, handler http.HandlerFunc) {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.handlers[name] = handler
}

func (r *HandlerRegistry) SetEnabled(name string, enabled bool) {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.enabled[name] = enabled
}

func (r *HandlerRegistry) ApplyToMux(mux *http.ServeMux, pathPrefix string) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    
    for name, handler := range r.handlers {
        if enabled, ok := r.enabled[name]; ok && enabled {
            mux.Handle(pathPrefix+name, handler)
        }
    }
}

这些模式都支持基于配置动态启用或禁用处理器，同时保持了代码的清晰性和可维护性。