如何在 Go 中构建自定义 HTTP 多路复用器 (Mux) 并实现高级路由功能

package main

import (
    "fmt"
    "net/http"
    "path" // 用于路径清理
    "regexp" // 用于动态路由匹配
    "context" // 用于传递请求参数
)

// 定义一个键类型，用于在请求上下文中存储参数
type contextKey string
const paramsContextKey contextKey = "params"

// CustomRouter 结构体，用于管理自定义路由
type CustomRouter struct {
    routes []route // 存储所有注册的路由
}

// route 结构体定义单个路由的模式和处理函数
type route struct {
    pattern *regexp.Regexp // 编译后的正则表达式模式
    handler http.Handler   // 对应的处理函数
    paramNames []string    // 从正则表达式中提取的参数名
}

// NewCustomRouter 创建并返回一个新的 CustomRouter 实例
func NewCustomRouter() *CustomRouter {
    return &CustomRouter{}
}

// ServeHTTP 是 CustomRouter 实现 http.Handler 接口的方法
func (cr *CustomRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 1. URL 路径清理
    cleanedPath := cleanPath(r.URL.Path)
    if cleanedPath != r.URL.Path {
        // 如果路径被清理，进行重定向
        r.URL.Path = cleanedPath // 更新请求的 URL 路径
        http.Redirect(w, r, r.URL.String(), http.StatusMovedPermanently)
        return
    }

    // 2. 动态路由匹配和参数提取
    for _, rt := range cr.routes {
        matches := rt.pattern.FindStringSubmatch(r.URL.Path)
        if matches != nil {
            // 提取路径参数
            params := make(map[string]string)
            for i, name := range rt.paramNames {
                if i < len(matches) {
                    params[name] = matches[i+1] // matches[0] 是整个匹配的字符串
                }
            }
            // 将参数存储到请求上下文中
            ctx := context.WithValue(r.Context(), paramsContextKey, params)
            // 调用对应的处理函数
            rt.handler.ServeHTTP(w, r.WithContext(ctx))
            return
        }
    }

    // 3. 如果没有匹配到任何自定义路由，则返回 404
    http.NotFound(w, r)
}

// cleanPath 规范化 URL 路径，移除多余的斜杠、"." 和 ".."
func cleanPath(p string) string {
    if p == "" {
        return "/"
    }
    if p[0] != '/' {
        p = "/" + p
    }
    // 使用 path.Clean 来处理各种非规范路径，例如 /a/./b, /a/../b, //a
    cleaned := path.Clean(p)
    // path.Clean 会移除末尾的斜杠，但对于根路径 "/" 应该保留
    if cleaned != "/" && p[len(p)-1] == '/' {
        return cleaned + "/"
    }
    return cleaned
}

// Handle 注册一个路由模式和对应的处理函数
func (cr *CustomRouter) Handle(pattern string, handler http.Handler) {
    // 将模式字符串（如 "/users/{id}"）转换为正则表达式
    // 匹配 {name} 形式的占位符
    re := regexp.MustCompile(`\{([a-zA-Z0-9_]+)\}`)

    // 存储提取到的参数名
    var paramNames []string

    // 构建正则表达式字符串
    regexStr := "^" + re.ReplaceAllStringFunc(pattern, func(s string) string {
        // s 的形式是 "{paramName}"
        paramName := s[1:len(s)-1] // 提取 "paramName"
        paramNames = append(paramNames, paramName)
        return `([^/]+)` // 匹配任意非斜杠字符
    }) + "$"

    compiledPattern := regexp.MustCompile(regexStr)

    cr.routes = append(cr.routes, route{
        pattern: compiledPattern,
        handler: handler,
        paramNames: paramNames,
    })
}

// HandleFunc 注册一个路由模式和对应的 http.HandlerFunc
func (cr *CustomRouter) HandleFunc(pattern string, handler http.HandlerFunc) {
    cr.Handle(pattern, handler)
}

// GetParams 从请求上下文中获取提取的路径参数
func GetParams(r *http.Request) map[string]string {
    if params, ok := r.Context().Value(paramsContextKey).(map[string]string); ok {
        return params
    }
    return nil
}

func main() {
    router := NewCustomRouter()

    // 注册一个处理根路径的路由
    router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "欢迎来到主页！当前路径：%s\n", r.URL.Path)
    })

    // 注册一个带有动态参数 {id} 的路由
    router.HandleFunc("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
        params := GetParams(r)
        if params != nil {
            userID := params["id"]
            fmt.Fprintf(w, "访问用户页面，用户ID：%s\n", userID)
        } else {
            fmt.Fprintf(w, "访问用户页面，但未找到用户ID。\n")
        }
    })

    // 注册一个带有多个动态参数的路由
    router.HandleFunc("/products/{category}/{product_id}", func(w http.ResponseWriter, r *http.Request) {
        params := GetParams(r)
        if params != nil {
            category := params["category"]
            productID := params["product_id"]
            fmt.Fprintf(w, "访问产品页面，分类：%s，产品ID：%s\n", category, productID)
        } else {
            fmt.Fprintf(w, "访问产品页面，但未找到分类或产品ID。\n")
        }
    })

    // 启动 HTTP 服务器
    port := ":8080"
    fmt.Printf("服务器正在监听 %s 端口...\n", port)
    err := http.ListenAndServe(port, router) // 使用我们自定义的 router
    if err != nil {
        panic(err)
    }
}