Go HTTP 服务器动态路由管理：自定义 ServeMux 实现处理器注销

package main

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

// MyMux 结构体，模仿 http.ServeMux 并添加注销功能
type MyMux struct {
    mu    sync.RWMutex // 读写锁保护 map
    m     map[string]muxEntry
    hosts bool // 是否有主机模式的路由（简化处理，实际需完整实现）
}

// muxEntry 存储处理器和对应的模式
type muxEntry struct {
    h       http.Handler
    pattern string
}

// NewMyMux 创建并返回一个 MyMux 实例
func NewMyMux() *MyMux {
    return &MyMux{m: make(map[string]muxEntry)}
}

// Handle 将处理器注册到给定模式。
// 逻辑与 http.ServeMux.Handle 类似。
func (mux *MyMux) Handle(pattern string, handler http.Handler) {
    mux.mu.Lock()
    defer mux.mu.Unlock()

    if pattern == "" {
        panic("http: invalid pattern")
    }
    if handler == nil {
        panic("http: nil handler")
    }
    // 实际 http.ServeMux 会检查主机模式冲突，这里简化
    mux.m[pattern] = muxEntry{h: handler, pattern: pattern}
}

// Deregister 移除与给定模式关联的处理器。
// 如果模式未注册，则返回错误。
func (mux *MyMux) Deregister(pattern string) error {
    mux.mu.Lock()
    defer mux.mu.Unlock()

    if _, ok := mux.m[pattern]; !ok {
        return fmt.Errorf("pattern %s not found", pattern)
    }
    delete(mux.m, pattern)
    return nil
}

// ServeHTTP 匹配请求路径并调用相应的处理器。
// 逻辑与 http.ServeMux.ServeHTTP 类似，但 handler 方法是简化版。
func (mux *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    h, _ := mux.handler(r) // 假设 handler 方法已实现
    h.ServeHTTP(w, r)
}

// handler 查找匹配给定请求的处理器。
// 注意：这是 http.ServeMux.handler 的简化版，
// 实际生产代码应完整复制 net/http/server.go 中的复杂匹配逻辑。
func (mux *MyMux) handler(r *http.Request) (h http.Handler, pattern string) {
    mux.mu.RLock()
    defer mux.mu.RUnlock()

    // 简化处理，不包含主机匹配逻辑
    return mux.match(r.URL.Path)
}

// match 查找匹配路径的处理器。
// 注意：这是 http.ServeMux.match 的简化版，
// 实际生产代码应完整复制 net/http/server.go 中的复杂匹配逻辑。
func (mux *MyMux) match(path string) (h http.Handler, pattern string) {
    // 确保路径以斜杠开头，并清理多余斜杠
    path = cleanPath(path)

    // 1. 精确匹配
    if entry, ok := mux.m[path]; ok {
        return entry.h, entry.pattern
    }

    // 2. 前缀匹配（最长匹配原则）
    var bestMatch string
    for p, entry := range mux.m {
        // 只有以斜杠结尾的模式才能作为前缀匹配
        // 并且请求路径必须以此模式开头
        if strings.HasSuffix(p, "/") && strings.HasPrefix(path, p) {
            if len(p) > len(bestMatch) {
                bestMatch = p
                h = entry.h
                pattern = entry.pattern
            }
        }
    }

    // 3. 如果没有匹配到，则返回 404 Not Found 处理器
    if h == nil {
        return http.NotFoundHandler(), ""
    }
    return h, pattern
}

// cleanPath 辅助函数，用于清理路径，与 http.CleanPath 类似，但为简化版。
func cleanPath(p string) string {
    if p == "" {
        return "/"
    }
    if p[0] != '/' {
        p = "/" + p
    }
    // 简化处理：仅移除非根路径末尾的斜杠
    if len(p) > 1 && p[len(p)-1] == '/' {
        p = p[:len(p)-1]
    }
    return p
}