一：golang自带路由介绍

golang自带路由库 http.ServerMux ，实际上是一个 map[string]Handler，是请求的url路径和该url路径对于的一个处理函数的映射关系。这个实现比较简单，有一些缺点：

  1. 不支持参数设定，例如/user/:uid 这种泛型类型匹配
  2. 无法很友好的支持REST模式，无法限制访问方法（POST，GET等）
  3. 也不支持正则

    二：gorilla/mux路由

    github地址：https://github.com/gorilla/mux http://www.gorillatoolkit.org/pkg/mux https://github.com/gorilla/mux#examples

上面所指出来的glang自带路由的缺点，gorilla/mux 都具备，而且还兼容 http.ServerMux。除了支持路径正则，命名路由，还支持中间件等等功能。所以mux是一个短小精悍，功能很全的路由。

1. 普通路由

示例 demo1.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gorilla/mux"
  6.     "net/http"
  7. )
  9. func main() {
  10.     r := mux.NewRouter()
  11.     //普通路由
  12.     r.HandleFunc("/", IndexHandler)
  13.     r.HandleFunc("/products", ProductsHandler)
  15.     http.ListenAndServe(":8080", r)
  16. }
  18. func IndexHandler(w http.ResponseWriter, r *http.Request) {
  19.     w.WriteHeader(http.StatusOK)
  20.     fmt.Fprintf(w, "hello world")
  21. }
  23. func ProductsHandler(w http.ResponseWriter, r *http.Request) {
  24.     w.WriteHeader(http.StatusOK)
  25.     fmt.Fprintf(w, "hello, Products")
  26. }

上面mux的普通路由是不是似曾相识，跟golang标准库用法一样

在浏览器访问：http://localhost:8080/products
输出：hello, Products

2. 参数路由

参数路由，可以是普通路由，还可以是正则匹配
示例 demo2.go：

  1. package main
  3. import (
  4.     "net/http"
  6.     "fmt"
  8.     "github.com/gorilla/mux"
  9. )
  11. //路由参数
  12. func main() {
  13.     r := mux.NewRouter()
  14.     //1. 普通路由参数
  15.     // r.HandleFunc("/articles/{title}", TitleHandler)
  17.     //2. 正则路由参数，下面例子中限制为英文字母
  18.     r.HandleFunc("/articles/{title:[a-z]+}", TitleHandler)
  20.     http.ListenAndServe(":8080", r)
  21. }
  23. //https://github.com/gorilla/mux#examples
  24. func TitleHandler(w http.ResponseWriter, r *http.Request) {
  25.     vars := mux.Vars(r) // 获取参数
  26.     w.WriteHeader(http.StatusOK)
  27.     fmt.Fprintf(w, "title: %v\n", vars["title"])
  28. }

第1个普通路由参数，就是啥参数都可以，不管是字母，数字，还是中文等
第2个正则路由参数，限制了只能是英文字母，否则会报 404 page not found

3. 路由匹配 Matching Routes

https://github.com/gorilla/mux#matching-routes
我们也可以限制路由或者子路由。

3.1 匹配host

  1. r := mux.NewRouter()
  2. //只匹配 www.example.com
  3. r.Host("www.example.com")
  4. // 动态匹配子路由
  5. r.Host("{subdomain:[a-z]+}.example.com")

3.2 更多的一些其他匹配

见下面的更多匹配的例子：

  1. r := mux.NewRouter()
  3. r.PathPrefix("/products/")    //前缀匹配
  4. r.Methods("GET", "POST")      //请求方法匹配
  5. r.Schemes("https")            //schemes
  6. r.Headers("X-Requested-With", "XMLHttpRequest")  //header 匹配
  7. r.Queries("key", "value")  //query的值匹配
  9. // 用户自定义方法 匹配
  10. r.MatcherFunc(func(r *http.Request, rm *RouteMatch) bool { 
  11.     return r.ProtoMajor == 0
  12. })

把上面的联合起来在一个单独的route里

  1. r.HandleFunc("/products", ProductsHandler).
  2.   Host("www.example.com").
  3.   Methods("GET").
  4.   Schemes("http")

3.3 子路由匹配

Subrouter() 可以设置子路由

  1. r := mux.NewRouter()
  2. s := r.Host("www.example.com").Subrouter()
  4. s.HandleFunc("/products/", ProductsHandler)
  5. s.HandleFunc("/products/{key}", ProductHandler)
  6. s.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)

3.4 多个路由匹配的顺序

如果有多个路由添加到路由器里面，那么匹配顺序是怎么样？按照添加的先后顺序匹配。比如有2个路由都匹配了，那么优先匹配第一个路由。

  1. r := mux.NewRouter()
  2. r.HandleFunc("/specific", specificHandler)
  3. r.PathPrefix("/").Handler(catchAllHandler)

4. 设置路由前缀

PathPrefix() 设置路由前缀

  1. r := mux.NewRouter()
  3. //PathPrefix() 可以设置路由前缀
  4. product := r.PathPrefix("/products").HandleFunc("/", ProductsHandler)

路由前缀一般情况下不会单独使用，而是和子路由结合起来用，实现路由分组

5. 分组路由

可以根据前面的子路由和路由前缀的功能，综合运用就可以设置分组路由了
实例：grouprouter.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gorilla/mux"
  6.     "net/http"
  7. )
  9. //子路由, 分组路由
  10. func main() {
  11.     r := mux.NewRouter()
  13.     //PathPrefix() 可以设置路由前缀，设置路由前缀为products
  14.     products := r.PathPrefix("/products").Subrouter()
  15.     //"http://localhost:8080/products/", 最后面的斜线一定要，不然路由不正确，页面出现404
  16.     products.HandleFunc("/", ProductsHandler)
  17.     //"http://localhost:8080/products/{key}"
  18.     products.HandleFunc("/{key}", ProductHandler)
  20.     users := r.PathPrefix("/users").Subrouter()
  21.     // "/users"
  22.     users.HandleFunc("/", UsersHandler)
  23.     // "/users/id/参数/name/参数"
  24.     users.HandleFunc("/id/{id}/name/{name}", UserHandler)
  26.     http.ListenAndServe(":8080", r)
  27. }
  29. func ProductsHandler(w http.ResponseWriter, r *http.Request) {
  30.     w.WriteHeader(http.StatusOK)
  31.     fmt.Fprintf(w, "%s", "products")
  32. }
  34. func ProductHandler(w http.ResponseWriter, r *http.Request) {
  35.     vars := mux.Vars(r) //获取路由的值
  36.     fmt.Fprintf(w, "key: %s", vars["key"])
  37. }
  39. func UsersHandler(w http.ResponseWriter, r *http.Request) {
  40.     fmt.Fprintf(w, " %s \r\n", "users handler")
  41. }
  43. func UserHandler(w http.ResponseWriter, r *http.Request) {
  44.     vars := mux.Vars(r) //获取值
  45.     id := vars["id"]
  46.     name := vars["name"]
  47.     fmt.Fprintf(w, "id: %s, name: %s \r\n", id, name)
  48. }

6. 路由中间

https://github.com/gorilla/mux#middleware
Mux middlewares are defined using the de facto standard type: 在mux中路由中间件的定义

type MiddlewareFunc func(http.Handler) http.Handler

示例1：middleware1.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  7.     "github.com/gorilla/mux"
  8. )
  10. func main() {
  11.     r := mux.NewRouter()
  12.     r.HandleFunc("/", handler)
  14.     r.Use(loggingMiddleware)
  16.     http.ListenAndServe(":8080", r)
  17. }
  19. func loggingMiddleware(next http.Handler) http.Handler {
  20.     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  21.         //Do stuff here
  22.         fmt.Println(r.RequestURI)
  23.         fmt.Fprintf(w, "%s\r\n", r.URL)
  24.         // Call the next handler, which can be another middleware in the chain, or the final handler.
  25.         next.ServeHTTP(w, r)
  26.     })
  27. }
  29. func handler(w http.ResponseWriter, r *http.Request) {
  30.     w.Write([]byte("handle middleware"))
  31.     fmt.Println("print handler")
  32. }

示例2：middleware2.go

在来看一个复杂点的例子：

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "strings"
  8.     "github.com/gorilla/mux"
  9. )
  11. type authMiddleware struct {
  12.     tokenUsers map[string]string
  13. }
  15. func (amw *authMiddleware) Populate() {
  16.     amw.tokenUsers = make(map[string]string)
  17.     amw.tokenUsers["000"] = "user0"
  18.     amw.tokenUsers["aaa"] = "userA"
  19.     amw.tokenUsers["05ft"] = "randomUser"
  20.     amw.tokenUsers["deadbeef"] = "user0"
  21. }
  23. func (amw *authMiddleware) Middleware(next http.Handler) http.Handler {
  24.     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  25.         token := strings.Trim(r.Header.Get("X-Session-Token"), " ")
  26.         if token == "" {
  27.             fmt.Fprintf(w, "token is error \r\n")
  28.         }
  30.         if user, found := amw.tokenUsers[token]; found {
  31.             //we found the token in out map
  32.             fmt.Printf("Authenticated user: %s\n", user)
  33.             fmt.Fprintf(w, "Authenticated user: %s\n", user)
  34.             // Pass down the request to the next middleware (or final handler)
  35.             next.ServeHTTP(w, r)
  36.         } else {
  37.             // Write an error and stop the handler chain
  38.             http.Error(w, "Forbidden", http.StatusForbidden)
  39.         }
  40.     })
  41. }
  43. func main() {
  44.     r := mux.NewRouter()
  45.     r.HandleFunc("/", handler)
  47.     amw := authMiddleware{}
  48.     amw.Populate()
  50.     r.Use(amw.Middleware)
  52.     http.ListenAndServe(":8080", r)
  53. }
  55. func handler(w http.ResponseWriter, r *http.Request) {
  56.     w.Write([]byte("handler"))
  57. }

7. Walking Routes 遍历注册的所有路由

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "strings"
  8.     "github.com/gorilla/mux"
  9. )
  11. func handler(w http.ResponseWriter, r *http.Request) {
  12.     return
  13. }
  15. //https://github.com/gorilla/mux#walking-routes
  16. func main() {
  17.     r := mux.NewRouter()
  18.     r.HandleFunc("/", handler)
  19.     r.HandleFunc("/products", handler).Methods("POST")
  20.     r.HandleFunc("/articles", handler).Methods("GET")
  21.     r.HandleFunc("/articles/{id}", handler).Methods("GET", "PUT")
  22.     r.HandleFunc("/authors", handler).Queries("surname", "{surname}")
  23.     err := r.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
  24.         pathTemplate, err := route.GetPathTemplate()
  25.         if err == nil {
  26.             fmt.Println("ROUTE:", pathTemplate)
  27.         }
  28.         pathRegexp, err := route.GetPathRegexp()
  29.         if err == nil {
  30.             fmt.Println("Path regexp:", pathRegexp)
  31.         }
  32.         queriesTemplates, err := route.GetQueriesTemplates()
  33.         if err == nil {
  34.             fmt.Println("Queries templates:", strings.Join(queriesTemplates, ","))
  35.         }
  36.         queriesRegexps, err := route.GetQueriesRegexp()
  37.         if err == nil {
  38.             fmt.Println("Queries regexps:", strings.Join(queriesRegexps, ","))
  39.         }
  40.         methods, err := route.GetMethods()
  41.         if err == nil {
  42.             fmt.Println("Methods:", strings.Join(methods, ","))
  43.         }
  44.         fmt.Println()
  45.         return nil
  46.     })
  48.     if err != nil {
  49.         fmt.Println(err)
  50.     }
  52.     http.Handle("/", r)
  53.     http.ListenAndServe(":8080", nil)
  54. }

8. 其他示例

请求方法限制

demo3.go:

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gorilla/mux"
  6.     "net/http"
  7. )
  9. // 请求方法的限制, Methods()
  10. func main() {
  11.     r := mux.NewRouter()
  13.     r.HandleFunc("/products", ProductsHandler).Methods("GET", "POST")
  15.     r.Handle("/products/{id}", &ProductsIdHandler{}).Methods("GET")
  16.     http.ListenAndServe(":8080", r)
  17. }
  19. func ProductsHandler(w http.ResponseWriter, r *http.Request) {
  20.     w.WriteHeader(http.StatusOK)
  21.     fmt.Fprintf(w, "hello, products! ")
  22. }
  24. type ProductsIdHandler struct{}
  26. func (handler *ProductsIdHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  27.     vars := mux.Vars(r)
  28.     w.WriteHeader(http.StatusOK)
  29.     fmt.Fprintf(w, "products id: %s", vars["id"])
  30. }

请求头限制

在路由定义中可以通过Headers() 方法来限制设置请求头的匹配。
demo4.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  7.     "github.com/gorilla/mux"
  8. )
  10. // 请求头的限制，用Headers() 来限制
  11. func main() {
  12.     r := mux.NewRouter()
  14.     r.HandleFunc("/products", func(w http.ResponseWriter, r *http.Request) {
  15.         header := "Request-Limit-Test"
  16.         fmt.Fprintf(w, "contain headers: %s = %s \n", header, r.Header[header])
  17.     }).Headers("Request-Limit-Test", "RequestLimitTest").Methods("POST")
  19.     http.ListenAndServe(":8080", r)
  20. }

自定义匹配规则

用 MatcherFunc() 来自定义规则
示例 demo5.go：**

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  7.     "github.com/gorilla/mux"
  8. )
  10. //自定义匹配 MatcherFunc()
  11. func main() {
  12.     r := mux.NewRouter()
  14.     r.HandleFunc("/products/matcher", func(w http.ResponseWriter, r *http.Request) {
  15.         fmt.Fprintf(w, "FormValue: %s ", r.FormValue("func"))
  16.     }).MatcherFunc(func(req *http.Request, match *mux.RouteMatch) bool {
  17.         b := false
  18.         if req.FormValue("func") == "matcherfunc" {
  19.             b = true
  20.         }
  21.         return b
  22.     })
  24.     http.ListenAndServe(":8080", r)
  25. }

在浏览器中：http://127.0.0.1:8080/products/matcher?func=matcherfunc
输出：FormValue: matcherfunc

命名路由 Registered URLs

namerouter.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gorilla/mux"
  6.     // "log"
  7.     "net/http"
  8. )
  10. // 命名路由 Name(), 获取路由URL， URL()
  11. func main() {
  12.     r := mux.NewRouter()
  13.     r.HandleFunc("/products/{category}/{id:[0-9]+}", ProductHandler).Name("product")
  15.     //获取路由的URL
  16.     url1, err := r.Get("product").URL()
  17.     fmt.Println(err) //error: mux: number of parameters must be multiple of 2, got [/]
  18.     if err == nil {
  19.         fmt.Println("get URL: \r\n", url1)
  20.     }
  22.     //获取路由的url后，也可以拼装你需要的URL
  23.     url2, err := r.Get("product").URL("category", "tech", "id", "13")
  24.     if err == nil {
  25.         fmt.Println("new url: ", url2) //new url:  /products/tech/13
  26.     }
  28.     http.ListenAndServe(":8080", r)
  29. }
  31. func ProductHandler(w http.ResponseWriter, r *http.Request) {
  32.     w.WriteHeader(http.StatusOK)
  33.     vars := mux.Vars(r)
  35.     fmt.Fprintf(w, "url: %s, category: %s, id: %s", r.URL, vars["category"], vars["id"])
  36.     //浏览器： http://localhost:8080/products/id/23
  38.     //output
  39.     //url: /products/id/23, category: id, id: 23
  40. }

根据命名的路由来获取路由URL r.Get(“product”).URL()

三：参考

https://github.com/gorilla/mux