go web编程——自定义路由设计

本文主要讲解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())
}

编译,运行,浏览器访问 http://localhost:4001/user/666/shiajun ,正确打印请求参数:

大功告成!

借鉴:

1. https://www.cnblogs.com/xxzhuang/p/9022941.html

2.《Go Web编程》

我来评几句
登录后评论

已发表评论数()

相关站点

热门文章