Go语言中实现动态注销HTTP路由处理器

package main

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

// MyMux 实现了 http.Handler 接口，并支持动态注册和注销处理器。
type MyMux struct {
    mu sync.RWMutex // 读写锁，保护 m 和 es
    m  map[string]muxEntry
    es []muxEntry // 存储模式列表，用于按长度排序匹配
}

// muxEntry 封装了处理器和模式字符串。
type muxEntry struct {
    h       http.Handler
    pattern string
}

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

// Handle 将给定的模式和处理器注册到 MyMux 中。
func (mux *MyMux) Handle(pattern string, handler http.Handler) {
    mux.mu.Lock()
    defer mux.mu.Unlock()

    // 确保模式以斜杠开头
    if pattern == "" {
        panic("http: invalid pattern " + pattern)
    }
    if pattern[0] != '/' {
        pattern = "/" + pattern
    }

    e := muxEntry{h: handler, pattern: pattern}
    mux.m[pattern] = e
    mux.es = append(mux.es, e)

    // 保持 es 降序排序，以便更具体的模式优先匹配
    sort.Slice(mux.es, func(i, j int) bool {
        return len(mux.es[i].pattern) > len(mux.es[j].pattern)
    })
}

// Deregister 从 MyMux 中注销指定模式的处理器。
// 如果模式不存在，则返回错误。
func (mux *MyMux) Deregister(pattern string) error {
    mux.mu.Lock()
    defer mux.mu.Unlock()

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

    delete(mux.m, pattern)

    // 从 es 中移除对应的 entry
    var newES []muxEntry
    for _, e := range mux.es {
        if e.pattern != pattern {
            newES = append(newES, e)
        }
    }
    mux.es = newES

    // 重新排序（如果需要，尽管删除操作可能不需要立即排序，但为了确保一致性，可以重新排序或在添加时确保排序）
    sort.Slice(mux.es, func(i, j int) bool {
        return len(mux.es[i].pattern) > len(mux.es[j].pattern)
    })

    return nil
}

// ServeHTTP 实现了 http.Handler 接口，根据请求路径匹配并调用相应的处理器。
func (mux *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    mux.mu.RLock() // 获取读锁
    defer mux.mu.RUnlock()

    // 尝试精确匹配
    if e, ok := mux.m[r.URL.Path]; ok {
        e.h.ServeHTTP(w, r)
        return
    }

    // 遍历 es 进行前缀匹配（最长匹配原则）
    for _, e := range mux.es {
        if strings.HasPrefix(r.URL.Path, e.pattern) {
            // 如果模式以斜杠结尾，则只匹配路径的前缀
            // 如果模式不以斜杠结尾，但路径匹配，且路径的下一个字符是斜杠，则也匹配
            if e.pattern[len(e.pattern)-1] == '/' ||
                (len(r.URL.Path) == len(e.pattern) || r.URL.Path[len(e.pattern)] == '/') {
                e.h.ServeHTTP(w, r)
                return
            }
        }
    }

    // 如果没有匹配到任何处理器，则返回 404 Not Found
    http.NotFound(w, r)
}

// MyHandler 是一个简单的 HTTP 处理器，根据其 ID 响应。
type MyHandler struct {
    id int
}

func (hf *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from MyHandler %d! Path: %s\n", hf.id, r.URL.Path)
}

// HandlerFactory 负责动态创建 MyHandler 实例并将其注册到 MyMux 中。
type HandlerFactory struct {
    nextHandlerID int
    mux           *MyMux
}

func (hf *HandlerFactory) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    hf.nextHandlerID++
    handler := &MyHandler{hf.nextHandlerID}
    pattern := fmt.Sprintf("/%d/", hf.nextHandlerID) // 例如：/1/, /2/
    hf.mux.Handle(pattern, handler)
    fmt.Fprintf(w, "Registered new handler for pattern: %s\n", pattern)
}

// HandlerDestroyer 负责从 MyMux 中注销 MyHandler 实例。
type HandlerDestroyer struct {
    mux *MyMux
}

func (hd *HandlerDestroyer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 期望请求路径如 /destroy/123，提取 ID 作为要注销的模式
    parts := strings.Split(r.URL.Path, "/")
    if len(parts) < 3 {
        http.Error(w, "Invalid destroy request. Usage: /destroy/{id}", http.StatusBadRequest)
        return
    }
    handlerID := parts[2] // 假设路径是 /destroy/ID
    pattern := fmt.Sprintf("/%s/", handlerID)

    err := hd.mux.Deregister(pattern)
    if err != nil {
        fmt.Fprintf(w, "Failed to deregister handler for pattern %s: %v\n", pattern, err)
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "Deregistered handler for pattern: %s\n", pattern)
}

func main() {
    myMux := NewMyMux()

    // 注册 HandlerFactory 和 HandlerDestroyer
    factory := &HandlerFactory{nextHandlerID: 0, mux: myMux}
    destroyer := &HandlerDestroyer{mux: myMux}

    myMux.Handle("/create", factory)
    myMux.Handle("/destroy/", destroyer) // 注意这里使用前缀匹配

    // 创建并启动 HTTP 服务器，使用自定义的 MyMux
    srv := &http.Server{
        Addr:    "localhost:8080",
        Handler: myMux, // 使用自定义的 MyMux
    }

    fmt.Println("Server listening on localhost:8080")
    fmt.Println("Visit /create to register new handlers (e.g., /1/, /2/)")
    fmt.Println("Visit /destroy/{id} to deregister handlers (e.g., /destroy/1)")
    if err := srv.ListenAndServe(); err != nil {
        fmt.Printf("Server failed: %v\n", err)
    }
}