标签：regexp png 读写锁 tar 正则表达 mpi 还需要 nic sub
本文主要讲解go语言web编程中自定义路由器的设计。在此之前需要先了解一下go语言web编程中路由与http服务的基本原理，可以参考笔者另一篇博文：go web编程——路由与http服务 。
我们已经知道，go的默认路由器只支持路由绝对匹配，无法支持正则匹配，这样就没办法设计一些简洁、优雅的路由。那怎么让路由支持正则匹配呢？通过阅读源码，可以发现http服务器和路由器之间是解耦的，调用 http.ListenAndServe(addr string, handler Handler) 方法启动http服务的时候，若第二个参数指定为 nil ，则会使用go的默认路由器，否则使用这个参数指定的路由器。所以，我们可以设计一个支持正则匹配的路由器，然后在第二个参数指定为我们自定义的路由器。
首先，我们要知道我们要设计的这个路由器需要符合什么条件，才能赋值给 http.ListenAndServe(addr string, handler Handler) 方法中的第二个参数。可以看到它的类型是 Handler ，而 Handler 是一个接口类型，源码如下：
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
所以我们自定义的路由器也需要实现这个接口。事实上go默认的路由器类型 ServeMux 也实现了这个接口，http服务处理客户端请求时会调用路由器的方法 ServeHTTP(ResponseWriter, *Request) 进行路由匹配和请求分发。这是http服务器和路由器唯一有交集的地方，所以只要我们自定义的路由器也定义方法 ServeHTTP(ResponseWriter, *Request) 并在其中实现我们自定义的路由匹配和请求分发，就完全可以使用我们自定义的路由器取代go默认的路由器，至于路由器结构怎么设计，路由怎么注册，又怎么匹配，都是我们说了算。
接下来先写一个简单的自定义路由器，取代go默认路由器，代码如下：
package main
import (
"log"
"net/http"
)
//路由器结构
type SimServeMux struct {
}
//路由匹配与请求分发
func (mux *SimServeMux) ServeHTTP(writer http.ResponseWriter, req *http.Request) {
if req.URL.Path == "/" {
sayHello(writer, req)
return
} else if req.URL.Path == "/haha" {
haha(writer, req)
return
}
http.NotFound(writer, req)
}
func main() {
log.Println("server running...")
log.Fatal(http.ListenAndServe("localhost:4001", &SimServeMux{}))
}
func sayHello(writer http.ResponseWriter, req *http.Request) {
writer.Write([]byte("hello world!"))
}
func haha(writer http.ResponseWriter, req *http.Request) {
writer.Write([]byte("haha!"))
}
编译，运行，浏览器访问 http://localhost:4001/ ，输出 hello world! ，访问http://localhost:4001/haha ，输出 haha! 。
可以看到，我们自定义的路由器已经取代go的默认路由器了。这是一个极其简单的路由器，只是定义了 ServeHTTP(ResponseWriter, *Request) 方法来进行路由匹配。
言归正传，接下来我们就来设计一个满足RESTful规则，而且支持正则匹配的路由器。
首先考虑路由器的结构，由于需要满足RESTful规则，可以使用一个 map 来存储注册路由，这个 map 的键为请求方法的名称，例如GET、POST等，map 的值则是路由结构体的切片（路由结构暂时未知）。这样做的好处是，进行路由匹配的时候，可以先根据请求方法过滤掉其他请求方法的路由，只需遍历当前请求方法的路由结构体切片进行匹配即可。考虑到并发请求，再加一个读写锁，所以路由器结构如下：
//路由器结构
type simMux struct {
mu sync.RWMutex //读写锁
m map[string][]HandlerStruc //路由映射
}
那么路由结构体的结构又应该是怎么样的呢？路由结构体除了保存响应函数，还需要保存一些额外的信息。假设我们要使用的正则路由规则形如 /user/:id([0-9]+)/:name([a-z]+) ，可以匹配的具体路由则形如 /user/666/shiajun ，那么我们在注册路由的时候，需要把正则表达式 /user/([0-9]+)/([a-z]+) 和请求参数名称 id、name 保存起来，而且要明确记录 id 是第一个参数，name 是第二个参数，这样路由匹配时对于请求路径 /user/666/shiajun 才知道 id 的值为666，name 的值为 shiajun ，所以路由结构体的结构如下：
//路由结构
type HandlerStruc struct {
regex *regexp.Regexp //正则对象
params map[int]string //请求参数
handler Handler //响应函数
}
type Handler func(http.ResponseWriter, *http.Request)
创建路由器对象的方法：
//创建路由器
func New() *simMux {
return &simMux{
sync.RWMutex{},
make(map[string][]HandlerStruc),
}
}
接下来就要实现一个注册路由的方法，注册路由的过程其实上面已经都解释得很清楚了，直接上代码：
//注册路由公共方法
//支持路由正则匹配，格式：/user/:id([0-9]+)/:name([a-z]+)
func (sMux *simMux) add(method string, pattern string, handler Handler) bool {
if len(pattern) == 0 || handler == nil {
return false
}
sMux.mu.Lock()
defer sMux.mu.Unlock()
params := make(map[int]string)
var patterns []string
pos := 0
arr := strings.Split(pattern, "/")
for _, v := range arr {
if strings.HasPrefix(v, ":") {
index := strings.Index(v, "(")
if index != -1 {
patterns = append(patterns, v[index:])
params[pos] = v[1:index]
pos++
continue
}
}
patterns = append(patterns, v)
}
regex, err := regexp.Compile(strings.Join(patterns, "/"))
if err != nil {
panic("simMux: wrong pattern \"" + pattern + "\"")
}
sMux.m[method] = append(sMux.m[method], HandlerStruc{regex, params, handler})
return true
}
然后封装各个请求方法的路由注册方法，方便调用：
//注册GET方法路由
func (sMux *simMux) AddGet(pattern string, handler Handler) bool {
return sMux.add(http.MethodGet, pattern, handler)
}
//注册POST方法路由
func (sMux *simMux) AddPost(pattern string, handler Handler) bool {
return sMux.add(http.MethodPost, pattern, handler)
}
//注册PUT方法路由
func (sMux *simMux) AddPut(pattern string, handler Handler) bool {
return sMux.add(http.MethodPut, pattern, handler)
}
//注册DELETE方法路由
func (sMux *simMux) AddDelete(pattern string, handler Handler) bool {
return sMux.add(http.MethodDelete, pattern, handler)
}
最后就是路由匹配与请求分发的实现了。根据请求方法定位到具体路由结构体切片，遍历切片进行正则匹配，若匹配成功，拼接请求参数，调用对应响应函数，代码如下：
//路由匹配与请求分发
func (sMux *simMux) ServeHTTP(writer http.ResponseWriter, req *http.Request) {
if sMux.m[req.Method] == nil || len(sMux.m[req.Method]) == 0 {
http.NotFound(writer, req)
return
}
path := req.URL.Path
for _, handlerStruc := range sMux.m[req.Method] {
if !handlerStruc.regex.MatchString(path) {
continue
}
matches := handlerStruc.regex.FindStringSubmatch(path)
if len(matches[0]) != len(path) {
continue
}
if len(handlerStruc.params) > 0 {
values := req.URL.Query()
for i, val := range matches[1:] {
values.Add(handlerStruc.params[i], val)
}
req.URL.RawQuery = url.Values(values).Encode()
}
handlerStruc.handler(writer, req)
return
}
http.NotFound(writer, req)
}
这样，一个满足RESTful规则，而且支持正则匹配的路由器就设计且实现完成了，我们可以来测试一下：
func main() {
sMux := mux.New()
sMux.AddGet("/", sayHello)
sMux.AddGet("/user/:id([0-9]+)/:name([a-z]+)", user)
fmt.Println(sMux)
log.Println("server running...")
log.Fatal(http.ListenAndServe("localhost:4001", sMux))
}
func sayHello(writer http.ResponseWriter, req *http.Request) {
writer.Write([]byte("hello world!"))
fmt.Fprintln(writer, req.URL.Query())
}
func user(writer http.ResponseWriter, req *http.Request) {
fmt.Fprintln(writer, req.URL.Query())
}
编译，运行，浏览器访问 http://localhost:4001/user/666/shiajun，正确打印请求参数：
大功告成！
借鉴：
1. https://www.cnblogs.com/xxzhuang/p/9022941.html
2.《Go Web编程》
标签：regexp png 读写锁 tar 正则表达 mpi 还需要 nic sub
原文地址：https://www.cnblogs.com/wujuntian/p/11858818.html
