随笔- 254 文章- 0 评论- 35 阅读- 57万

自定义路由设计

本文主要讲解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 //动态路由
    static map[string]string         //静态路由
}

那么路由结构体的结构又应该是怎么样的呢？路由结构体除了保存响应函数，还需要保存一些额外的信息。假设我们要使用的正则路由规则形如 /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),
        make(map[string]string),
    }
}

接下来就要实现一个注册路由的方法，注册路由的过程其实上面已经都解释得很清楚了，直接上代码：

//注册静态路由
func (sMux *simMux) AddStatic(prefix, path string) bool {
    if len(prefix) == 0 || len(path) == 0 {
        return false
    }
    _, exist := sMux.static[prefix]
    if exist {
        panic("simMux: duplicate static prefix \"" + prefix + "\"")
    }
    sMux.static[prefix] = path
    return true
}
//注册动态路由
//支持路由正则匹配，格式：/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) {
    //静态路由解析
    for prefix, path := range sMux.static {
        if strings.HasPrefix(req.URL.Path, prefix) {
            file := path + req.URL.Path[len(prefix):]
            http.ServeFile(writer, req, file)
            return
        }
    }
    //动态路由解析
    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("/user/:id([0-9]+)/:name([a-z]+)", user)
    log.Println("server running...")
    log.Fatal(http.ListenAndServe("localhost:4001", sMux))
}
func user(writer http.ResponseWriter, req *http.Request) {
    fmt.Fprintln(writer, req.URL.Query())
}