使用gorilla/mux增强Go HTTP服务器的路由能力

今天这篇文章我们将会为我们之前编写的 HTTP服务器加上复杂路由的功能以及对路由进行分组管理。在之前的文章《深入学习用 Go 编写HTTP服务器》中详细地讲了使用 net/http进行路由注册、监听网络连接、处理请求、安全关停服务的实现方法，使用起来非常方便。但是 net/http有一点做的不是非常好的是，它没有提供类似 URL片段解析、路由参数绑定这样的复杂路由功能。好在在 Go社区中有一个非常流行的 gorilla/mux包，它提供了对复杂路由功能的支持。在今天这篇文章中我们将探究如何用 gorilla/mux包来创建具有命名参数、 GET/POST处理、分组前缀、限制访问域名的路由。

安装gorilla/mux包

我们在之前写的 HTTP服务的代码根目录，使用go get命令从GitHub安装软件包，如下所示：

1. go get github.com/gorilla/mux

在《深入学习用 Go 编写HTTP服务器》中我们介绍过路由注册、匹配和最后处理函数的调用都是由 ServeMux(服务复用器)来完成的，而且我们还自己定义了复用器用以替换默认的 DefaultServeMux。同样的 gorilla/mux包也是为我们提供了一个复用器。这个复用器拥有很多功能用以提升编写 Web应用的效率，而且与标准的 http.ServeMux兼容。

使用gorilla/mux包

创建路由器

可以像下面这样创建一个路由器

1. router := mux.NewRouter()

会返回一个 mux.Router实例， mux.Router将传入的请求与已注册路由列表进行匹配，并为与 URL或其他条件匹配的路由调用处理程序。主要特点是：

• 可以根据URL主机，路径，路径前缀， Header头、查询值， HTTP方法进行路由匹配，或是使用自定义匹配器。

• URL主机，路径和查询值可以是带有可选正则表达式的变量。

• 路由可以被用作子路由，只有父路由匹配后才会尝试匹配子路由。这对于定义路由组非常有用，路由组可以共享主机、路径前缀、或者其他常见的属性。

• 它实现了http.Handler接口，因此与标准的 http.ServeMux完全兼容。

注册路由处理程序

我们将之前程序里自定义的服务复用器替换成上面创建好 mux.Router，并为其注册路由处理器。

1. type helloHandler struct{}

2. func (*helloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

3. fmt.Fprintf(w, "Hello World")

4. }

5. func WelcomeHandler(w http.ResponseWriter, r *http.Request) {

6. fmt.Fprintf(w, "Welcome!")

7. }

8. func main() {

9. router := mux.NewRouter()

10. router.Handle("/", &helloHandler{})

11. router.HandleFunc("/welcome", WelcomeHandler)

12. ......

13. }

之前我们是用 http.Hanle， http.HandleFunc注册处理程序的，这里直接换成 router.Hanle和 router.HanleFunc即可，很方便。

定义带命名参数的路由

使用 mux.Router的最大优势是可以从请求 URL中提取分段，然后作为命名参数传入路由处理程序供使用。

接下来为我们的程序注册一个路由处理器，让服务器能够处理 URL为 /names/Gorge/countries/NewZealand的请求:

1. router.HandleFunc("/names/{name}/countries/{country}", func(writer http.ResponseWriter, request *http.Request) {

2. ......

3. })

接下来在处理函数中使用 mux.Vars()函数从这些 URL分段中获取数据。该函数以 http.Request为参数并返回一个 URL分段名为键，提取的数据为值的字典。

1. func(writer http.ResponseWriter, request *http.Request) {

2. vars := mux.Vars(request)

3. name := vars["name"]

4. country := vars["country"]

5. fmt.Fprintf(writer, "This guy named %s, was coming from %s .", name, country)

6. })

让服务器使用我们创建的路由器

这个设置很简单，如果没有自定义 http.Server对象，使用 http.ListenAndServe(":8000",router)，使用自己定义的`http.Server 对象时则是：

1. server := &http.Server{

2. Addr: ":8080",

3. Handler: router,

4. }

这个和我们把自定义的服务复用器传递给 http.Server没有任何区别。

改造完后我们之前写的 HTTP服务器就可以根据具体的 URL 动态地构造响应。关键字回复 gohttp02可获得完整的源代码

其他gorilla/mux路由器的常用功能

设置路由的HTTP方法

限制路由处理器只处理指定的 HTTP方法的请求：

1. router.HandleFunc("/books/{title}", CreateBook).Methods("POST")

2. router.HandleFunc("/books/{title}", ReadBook).Methods("GET")

3. router.HandleFunc("/books/{title}", UpdateBook).Methods("PUT")

4. router.HandleFunc("/books/{title}", DeleteBook).Methods("DELETE")

上面的就是一组可以响应具体 HTTP方法的 RESTful风格的接口的路由。

设置路由的域名

限制路由处理器只处理访问指定域名加路由的请求：

1. router.HandleFunc("/books/{title}", BookHandler).Host("www.mybookstore.com")

限制HTTP方案

将请求处理程序可响应的 HTTP方案限制为 http或者 https。

1. router.HandleFunc("/secure", SecureHandler).Schemes("https")

2. router.HandleFunc("/insecure", InsecureHandler).Schemes("http")

设置路径前缀和子路由

1. bookrouter := router.PathPrefix("/books").Subrouter()

2. bookrouter.HandleFunc("/", AllBooks)

3. bookrouter.HandleFunc("/{title}", GetBook)

使用gorilla/mux改进我们的HTTP服务器

接下来我们使用 gorilla/mux对我们之前写的 HTTP服务器做一下改进，之前我们所有程序都放在了 main.go中，现在我们的程序还很小，所以我们先不把项目目录规划的太复杂，先通过文件做下简单的职责划分，新建两个文件 router.go和 handler.go分别用来存放路由注册的逻辑和路由对应的处理器函数，两个文件的示例内容如下。

handler.go:

1. package main

2. import (

3. "fmt"

4. "github.com/gorilla/mux"

5. "net/http"

6. )

7. type HelloHandler struct{}

8. func (*HelloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

9. fmt.Fprintf(w, "Hello World")

10. }

11. func ShowVisitorInfo(writer http.ResponseWriter, request *http.Request) {

12. vars := mux.Vars(request)

13. name := vars["name"]

14. country := vars["country"]

15. fmt.Fprintf(writer, "This guy named %s, was coming from %s .", name, country)

16. }

router.go:

1. package main

2. import (

3. "github.com/gorilla/mux"

4. )

5. func RegisterRoutes(r *mux.Router) {

6. indexRouter := r.PathPrefix("/index").Subrouter()

7. indexRouter.Handle("/", &HelloHandler{})

8. userRouter := r.PathPrefix("/user").Subrouter()

9. userRouter.HandleFunc("/names/{name}/countries/{country}", ShowVisitorInfo)

10. }

在 router.go中我们将路由分为 index和 user两组，在两个路由组上分别定义路由。将这部分封装在一个导出函数 RegisterRoutes供调用。这样即使以后路由注册的程序要放到单独的目录里也可以供外部调用。

整理完后我们的 main.go中就会变的很简洁：

1. func main() {

2. //mux := http.NewServeMux()

3. //mux.Handle("/", &helloHandler{})

4. muxRouter := mux.NewRouter()

5. RegisterRoutes(muxRouter)

6. server := &http.Server{

7. Addr: ":8080",

8. Handler: muxRouter,

9. }

10. ......

11. err := server.ListenAndServe()

12. ......

13. }

关注公众号里回复 gohttp02获取本文中完整的示例代码。

前文回顾：深入学习用 Go 编写HTTP服务器

喜欢我的文章，帮忙转发点赞，如在实践过程中遇到什么问题可在下方给我留言。