http.HandleFunc 模式中的通配符

Question

注册处理程序时，有没有办法在模式中指定通配符？

例如：

http.HandleFunc("/groups/*/people", peopleInGroupHandler)

其中 * 可以是任何有效的 URL 字符串。或者是匹配 /groups 并从处理程序 (peopleInGroupHandler) 函数中计算出其余部分的唯一解决方案？

Answer 1

http.Handler 和 http.HandleFunc 的模式不是正则表达式或 glob。没有办法指定通配符。它们记录在此处。

也就是说，创建您自己的可以使用正则表达式或您想要的任何其他类型的模式的处理程序并不太难。这是使用正则表达式的一个（已编译，但未经测试）：

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
        }
    }
    // no pattern matched; send 404 response
    http.NotFound(w, r)
}

Answer 2

自 2011 年以来，您现在（2014 年以上）可以找到其他解决方案。
例如，Gorilla Web 工具包的 mux 包提供了所有类型的路由选项：

• 请求路径上的模式匹配，以及可选的正则表达式。
• URL 主机和方案、请求方法、标头和查询值的匹配。
• 基于自定义功能的匹配。
• 使用子路由器可以轻松实现嵌套路由。

它可以轻松集成到任何 BYOR（自带路由器）http 库，如 negroni。

以下是文章“Gorilla vs Pat vs Routes：A Mux Showdown”中的示例：

package main

import (
  "github.com/gorilla/mux"
  "log"
  "net/http"
)

func main() {
  rtr := mux.NewRouter()
  rtr.HandleFunc("/user/{name:[a-z]+}/profile", profile).Methods("GET")

  http.Handle("/", rtr)

  log.Println("Listening...")
  http.ListenAndServe(":3000", nil)
}

func profile(w http.ResponseWriter, r *http.Request) {
  params := mux.Vars(r)
  name := params["name"]
  w.Write([]byte("Hello " + name))
}

有时最好不要只使用另一个“神奇”包，而是了解幕后发生的事情

在这种情况下，“魔法”是在“gorilla/mux/regexp.go”，以及 在这里测试。
这个想法是提取命名变量，组装要匹配的正则表达式，创建“反向”模板来构建 URL 并编译正则表达式以验证 URL 构建中使用的变量值。

Answer 3

以下是如何使用 @evanshaw 的代码示例的示例

func handleDigits(res http.ResponseWriter, req *http.Request) {
    res.Write([]byte("Digits in the URL\n"))
}

func handleStrings(res http.ResponseWriter, req *http.Request) {
    res.Write([]byte("Strings in the URL\n"))
}

func main() {
    handler := &RegexpHandler{}

    reg1, _ := regexp.Compile("/foo-\\d+")
    handler.HandleFunc(reg1, handleDigits)

    reg2, _ := regexp.Compile("/foo-\\w+")
    handler.HandleFunc(reg2, handleStrings)

    http.ListenAndServe(":3000", handler)
}

Answer 4

我只是想添加 julienschmidt/httprouter，它的行为类似于 net/http，但带有一个用于 url 值的附加参数和对请求方法的支持：

https://github.com/julienschmidt/httprouter

package main

import (
    "fmt"
    "github.com/julienschmidt/httprouter"
    "net/http"
    "log"
)

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    fmt.Fprint(w, "Welcome!\n")
}

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
}

func main() {
    router := httprouter.New()
    router.GET("/", Index)
    router.GET("/hello/:name", Hello)

    log.Fatal(http.ListenAndServe(":8080", router))
}

它似乎也比gorilla/mux（根据 GitHub），它还声称需要更少的内存。

https://github.com/julienschmidt/go-http-routing-benchmark

Answer 5

您可以检查 violetear 如何处理动态+包罗万象（通配符）模式，这只是为了补充，例如：

uuid := `[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}`
router.AddRegex(":uuid")
router.HandleFunc("/test/:uuid/:uuid", handleUUID, "GET,HEAD")

在本例中，请求可能有 2 个不同的 UUIDS

对于动态/通配符，这可能适用：

http://api.violetear.org/command/ping/127.0.0.1
                        \______/\___/\________/
                            |     |      |
                             static      |
                                      dynamic

可以使用正则表达式来匹配 IP：

router.AddRegex(":ip", `^(?:[0-9]{1,3}\.){3}[0-9]{1,3}
您可以检查 violetear 如何处理动态+包罗万象（通配符）模式，这只是为了补充，例如：
uuid := `[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}`
router.AddRegex(":uuid")
router.HandleFunc("/test/:uuid/:uuid", handleUUID, "GET,HEAD")

在本例中，请求可能有 2 个不同的 UUIDS
对于动态/通配符，这可能适用：
http://api.violetear.org/command/ping/127.0.0.1
                        \______/\___/\________/
                            |     |      |
                             static      |
                                      dynamic

可以使用正则表达式来匹配 IP：
)
router.HandleFunc("/command/ping/:ip", ipHandler, "GET")

或者只是一个捕获所有允许 GET 和仅限 HEAD 方法：

router.HandleFunc("/command/ping/*", anyHandler, "GET, HEAD")

更多示例可在此处找到：https:// /violetear.org/post/how-it-works/

Answer 6

注册处理程序时通常不指定通配符。

包含通配符的路由维护在路由表中，根据用户输入进行编译，然后传递给适当的处理函数。

我偶然发现 Ben Hoyt 关于 Go 中 HTTP 路由的博客，其中他描述了自定义技术并将其与第三方的。我强烈建议任何阅读本文的人都仔细阅读它。另外，Gorilla'x mux 包现已存档

下面的方法基于正则表达式表，其中我们循环遍历预编译的正则表达式并使用请求上下文传递匹配项。

package main

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

var routes = []route{
    newRoute("GET", "/", home),
    newRoute("GET", "/([^/]+)", sink),
    newRoute("GET", "/groups/([^/]+)/people", peopleInGroupHandler),
}

func newRoute(method, pattern string, handler http.HandlerFunc) route {
    return route{method, regexp.MustCompile("^" + pattern + "$"), handler}
}

type route struct {
    method  string
    regex   *regexp.Regexp
    handler http.HandlerFunc
}

func Serve(w http.ResponseWriter, r *http.Request) {
    var allow []string
    for _, route := range routes {
        matches := route.regex.FindStringSubmatch(r.URL.Path)
        if len(matches) > 0 {
            if r.Method != route.method {
                allow = append(allow, route.method)
                continue
            }
            ctx := context.WithValue(r.Context(), ctxKey{}, matches[1:])
            route.handler(w, r.WithContext(ctx))
            return
        }
    }
    if len(allow) > 0 {
        w.Header().Set("Allow", strings.Join(allow, ", "))
        http.Error(w, "405 method not allowed", http.StatusMethodNotAllowed)
        return
    }
    http.NotFound(w, r)
}

type ctxKey struct{}

func getField(r *http.Request, index int) string {
    fields := r.Context().Value(ctxKey{}).([]string)
    return fields[index]
}

func home(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "HOME\n")
}

func peopleInGroupHandler(w http.ResponseWriter, r *http.Request) {
    slug := getField(r, 0)
    fmt.Fprintf(w, "Group handler: %s\n", slug)
}

func sink(w http.ResponseWriter, r *http.Request) {
    slug := getField(r, 0)
    fmt.Fprintf(w, "Sink %s\n", slug)
}


func main() {
    http.ListenAndServe("127.0.0.1:8080", http.HandlerFunc(Serve))
}

请求和响应示例

curl -X GET http://127.0.0.1:8080
HOME

curl -X GET http://127.0.0.1:8080/
HOME

curl -X GET http://127.0.0.1:8080/temp
Sink temp

curl -X GET http://127.0.0.1:8080/groups/south-park/people
People in group south-park

curl -X GET http://127.0.0.1:8080/groups/6/people
People in group 6

---