Go HTTP路由中正则表达式的常见陷阱与精确匹配实践

package main

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

// runTest 处理8个字符/数字组合的路径
func runTest(w http.ResponseWriter, r *http.Request) {
    path := r.URL.Path[1:]
    fmt.Fprintf(w, "Matched by runTest: %s", path)
} 

// runTest2 处理特定文件扩展名的路径
func runTest2(w http.ResponseWriter, r *http.Request) {
    path := "Matched by runTest2: .[(css|jpg|png|js|ttf|ico)]$" // 错误的正则表达式
    fmt.Fprintf(w, path)
} 

// runTest3 处理 /all 路径
func runTest3(w http.ResponseWriter, r *http.Request) {
    path := "Matched by runTest3: /all$" 
    fmt.Fprintf(w, path)
} 

// route 结构体，包含正则表达式和对应的处理器
type route struct {
    pattern *regexp.Regexp
    handler http.Handler
}

// RegexpHandler 结构体，管理所有正则表达式路由
type RegexpHandler struct {
    routes []*route
}

// Handler 方法添加一个 http.Handler 类型的路由
func (h *RegexpHandler) Handler(pattern *regexp.Regexp, handler http.Handler) {
    h.routes = append(h.routes, &route{pattern, handler})
}

// HandleFunc 方法添加一个 http.HandlerFunc 类型的路由
func (h *RegexpHandler) HandleFunc(pattern *regexp.Regexp, handler func(http.ResponseWriter, *http.Request)) {
    h.routes = append(h.routes, &route{pattern, http.HandlerFunc(handler)})
}

// ServeHTTP 方法实现 http.Handler 接口，进行路由匹配和分发
func (h *RegexpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    for _, route := range h.routes {
        if route.pattern.MatchString(r.URL.Path) {
            route.handler.ServeHTTP(w, r)
            return // 匹配成功后立即返回
        }
    }
    http.NotFound(w, r) // 未找到匹配的路由
}

func main() {
    handler := &RegexpHandler{} 
    // 注册路由，注意顺序
    handler.HandleFunc(regexp.MustCompile(`.[(css|jpg|png|js|ttf|ico)]$`), runTest2) // 问题正则表达式
    handler.HandleFunc(regexp.MustCompile("^/all$"), runTest3) 
    handler.HandleFunc(regexp.MustCompile("^/[A-Z0-9a-z]{8}$"), runTest)  
    http.ListenAndServe(":8080", handler)
}

func main() {
    handler := &RegexpHandler{} 
    // 修正后的正则表达式
    handler.HandleFunc(regexp.MustCompile(`\.(css|jpg|png|js|ttf|ico)$`), runTest2) 
    handler.HandleFunc(regexp.MustCompile("^/all$"), runTest3) 
    handler.HandleFunc(regexp.MustCompile("^/[A-Z0-9a-z]{8}$"), runTest)  
    http.ListenAndServe(":8080", handler)
}

package main

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

// This is the handler when passing a string of 8 characters ([])
func runTest(w http.ResponseWriter, r *http.Request) {
    path := r.URL.Path[1:]
    fmt.Fprintf(w, "Matched by runTest: %s", path)
} 

func runTest2(w http.ResponseWriter, r *http.Request) {
    path := "Matched by runTest2: file extension handler" 
    fmt.Fprintf(w, path)
} 

func runTest3(w http.ResponseWriter, r *http.Request) {
    path := "Matched by runTest3: /all handler" 
    fmt.Fprintf(w, path)
} 

// Regular expression handler
type route struct {
    pattern *regexp.Regexp
    handler http.Handler
}

type RegexpHandler struct {
    routes []*route
}

func (h *RegexpHandler) Handler(pattern *regexp.Regexp, handler http.Handler) {
    h.routes = append(h.routes, &route{pattern, handler})
}

func (h *RegexpHandler) HandleFunc(pattern *regexp.Regexp, handler func(http.ResponseWriter, *http.Request)) {
    h.routes = append(h.routes, &route{pattern, http.HandlerFunc(handler)})
}

func (h *RegexpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    for _, route := range h.routes {
        if route.pattern.MatchString(r.URL.Path) {
            route.handler.ServeHTTP(w, r)
            return
        }
    }
    http.NotFound(w, r)
}

func main() {
    handler := &RegexpHandler{} 
    // 修正后的正则表达式，确保匹配行为符合预期
    handler.HandleFunc(regexp.MustCompile(`\.(css|jpg|png|js|ttf|ico)$`), runTest2)
    handler.HandleFunc(regexp.MustCompile("^/all$"), runTest3) 
    handler.HandleFunc(regexp.MustCompile("^/[A-Z0-9a-z]{8}$"), runTest)  
    http.ListenAndServe(":8080", handler)
}