远航

为了远方的诗以及苟且

高机能可扩大 HTTP 路由 httprouter

2019年1月21日 0条谈论 2,126次阅读 2人点赞

Go言语(golang)的一个很大的劣势，就是很容易的开辟出网络后盾效劳，并且机能快，效力高。在开辟后端HTTP网络使用效劳的时辰，咱们需求处置不少HTTP的要求拜访，比方罕见的API效劳，咱们就要处置不少HTTP要求，而后把处置的信息前往给应用者。关于这种需要，Golang提供了内置的net/http包帮咱们来处置这些HTTP要求，让咱们可以比力不便的开辟一个HTTP效劳。

net/http

func main() {
	http.HandleFunc("/",Index)

	log.Fatal(http.ListenAndServe(":8080", nil))
}

func Index(w http.ResponseWriter, r *http.Request){
	fmt.Fprint(w,"Blog:www.flysnow.org\nwechat:flysnow_org")
}

这是net/http包中一个经典的HTTP效劳完成，咱们运转后翻开http://localhost:8080，就能看到以下信息:

Blog:www.flysnow.org
wechat:flysnow_org

显现的关头就是咱们http.HandleFunc函数，咱们经由过程该函数注册了对途径/的处置函数Index，一切才会看到下面的显现信息。那末这个http.HandleFunc他是若何注册Index函数的呢？上面看看这个函数的源代码。

// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	DefaultServeMux.HandleFunc(pattern, handler)
}

type ServeMux struct {
	mu    sync.RWMutex
	m     map[string]muxEntry
	hosts bool // whether any patterns contain hostnames
}

看以上的源代码，是存在一个默许的DefaultServeMux路由的，这个DefaultServeMux类型是ServeMux,咱们注册的途径函数信息都被存入ServeMux的m字段中，以便处置HTTP要求的时辰应用。

DefaultServeMux.HandleFunc函数终极会挪用ServeMux.Handle函数。

func (mux *ServeMux) Handle(pattern string, handler Handler) {
	//省稍加锁以及判断代码

	if mux.m == nil {
		mux.m = make(map[string]muxEntry)
	}
	//把咱们注册的途径以及响应的处置函数存入了m字段中
	mux.m[pattern] = muxEntry{h: handler, pattern: pattern}

	if pattern[0] != '/' {
		mux.hosts = true
	}
}

这下应当大白了，注册的途径以及响应的处置函数都存入了m字段中。

既然注册存入了响应的信息，那末在处置HTTP要求的时辰，就能应用了。Go言语的net/http更底层细节就不具体阐发了，咱们只需晓得处置HTTP要求的时辰，会挪用Handler接口的ServeHTTP法子，而ServeMux正好完成了Handler。

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
	//省略一些有关代码
	
	h, _ := mux.Handler(r)
	h.ServeHTTP(w, r)
}

下面代码中的mux.Handler会获取到咱们注册的Index函数，而后执行它，详细mux.Handler的具体完成再也不阐发了，大师可以本人看下源代码。

此刻咱们可以总结下net/http包对HTTP要求的处置。

HTTP要求->ServeHTTP函数->ServeMux的Handler法子->Index函数

这就是整个一条要求处置链，此刻咱们大白了net/http里对HTTP要求的原理。

net/http 的缺乏

咱们本人在应用内置的net/http的默许途径处置HTTP要求的时辰，会发明不少缺乏，比方：

  1. 不克不及独自的对要求法子(POST,GET等)注册特定的处置函数
  2. 不支持Path变量参数
  3. 不克不及自动对Path举行校准
  4. 机能通常
  5. 扩大性缺乏
  6. ……

那末若何解决以上问题呢？一个措施就是本人写一个处置HTTP要求的路由，由于从下面的源代码咱们晓得，net/http用的是默许的途径。

//这个是咱们启动HTTP效劳的函数，最初一个handler参数是nil
http.ListenAndServe(":8080", nil)

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	handler := sh.srv.Handler
	
	//这个判断建立，由于咱们传送的是nil
	if handler == nil {
		handler = DefaultServeMux
	}
	//省略了一些代码
	handler.ServeHTTP(rw, req)
}

经由过程以上的代码阐发，咱们本人在经由过程http.ListenAndServe函数启动一个HTTP效劳的时辰，最初一个handler的值是nil，以是下面的nil判断建立，应用的就是默许的路由DefaultServeMux。

此刻咱们就晓得若何应用本人界说的路由了，那就是给http.ListenAndServe的最初一个参数handler传一个自界说的路由，比方：

type CustomMux struct {

}

func (cm *CustomMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w,"Blog:www.flysnow.org\nwechat:flysnow_org")
}

func main() {
	log.Fatal(http.ListenAndServe(":8080", &CustomMux{}))
}

这个自界说的CustomMux就是咱们的路由，它显现了以及应用net/http演示的例子同样的功效。

此刻咱们改动下代码，只有GET法子才会显现以上信息。

func (cm *CustomMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method =="GET" {
		fmt.Fprint(w,"Blog:www.flysnow.org\nwechat:flysnow_org")
	} else {
		fmt.Fprint(w,"bad http method request")
	}
}

只要要改动下ServeHTTP法子的处置逻辑便可，此刻咱们可以换差别的要求法子尝尝，就会显现差别的内容。

这个就是自界说，咱们可以经由过程扩大ServeHTTP法子的完成来增加咱们想要的任何功效，包含下面章节列进去的net/http的缺乏均可以解决，不外咱们无需这么贫苦，由于开源大牛曾经帮咱们做了这些事件，它就是 《高达VS》β测试支持跨服玩家对战

httprouter

httprouter 是一个高机能、可扩大的HTTP路由，下面咱们罗列的net/http默许路由的缺乏，都被httprouter 完成，咱们先用一个例子，熟悉下 httprouter 这个强盛的 HTTP 路由。

package main

import (
	"fmt"
	"github.com/julienschmidt/httprouter"
	"net/http"
	"log"
)

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
	fmt.Fprintf(w,"Blog:%s \nWechat:%s","www.flysnow.org","flysnow_org")
}
func main() {
	router := httprouter.New()
	router.GET("/", Index)

	log.Fatal(http.ListenAndServe(":8080", router))
}

这个例子，完成了在GET要求/途径时，会显现以下信息：

Blog:www.flysnow.org
wechat:flysnow_org

在这个例子中，起首经由过程httprouter.New()天生了一个*Router路由指针,而后应用GET法子注册一个适配/途径的Index函数，最初*Router作为参数传给ListenAndServe函数启动HTTP效劳便可。

并不止是GET法子，httprouter 为一切的HTTP Method 提供了快捷的应用体式格局，只要要挪用对应的法子便可。

func (r *Router) GET(path string, handle Handle) {
	r.Handle("GET", path, handle)
}

func (r *Router) HEAD(path string, handle Handle) {
	r.Handle("HEAD", path, handle)
}

func (r *Router) OPTIONS(path string, handle Handle) {
	r.Handle("OPTIONS", path, handle)
}

func (r *Router) POST(path string, handle Handle) {
	r.Handle("POST", path, handle)
}

func (r *Router) PUT(path string, handle Handle) {
	r.Handle("PUT", path, handle)
}

func (r *Router) PATCH(path string, handle Handle) {
	r.Handle("PATCH", path, handle)
}

func (r *Router) DELETE(path string, handle Handle) {
	r.Handle("DELETE", path, handle)
}

以上这些法子都是 httprouter 支持的，咱们可以很是机动的按照需求，应用对应的法子，如许就解决了net/http默许路由的问题。

httprouter 定名参数

古代的API，根基上都是Restful API，httprouter提供的定名参数的支持，可以很不便的扶助咱们开辟Restful API。比方咱们设计的API/user/flysnow，这如许一个URL，可以查看flysnow这个用户的信息，若是要查看其余用户的，比方zhangsan,咱们只要要拜访API/user/zhangsan便可。

此刻咱们可以发明，实在这是一种URL婚配形式，咱们可以把它总结为/user/:name,这是一个通配符，看个例子。

func UserInfo(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	fmt.Fprintf(w,"hello, %s!\n", ps.ByName("name"))
}

func main() {
	router := httprouter.New()
	router.GET("/user/:name",UserInfo)

	log.Fatal(http.ListenAndServe(":8080", router))
}

当咱们运转，在欣赏器里输出http://localhost:8080/user/flysnow时，就会显现hello, flysnow!.

经由过程下面的代码示例，可以看到，途径的参数因此:结尾的，前面紧随着变量名，比方:name，而后在UserInfo这个处置函数中，经由过程httprouter.Params的ByName获取对应的值。

:name这类婚配形式，是精准婚配的，同时只能婚配一个，比方：

Pattern: /user/:name

 /user/gordon              婚配
 /user/you                 婚配
 /user/gordon/profile      不婚配
 /user/                    不婚配

由于httprouter这个路由就是繁多婚配的，以是当咱们应用定名参数的时辰，必然要注重，是不是有其余注册的路由以及定名参数的路由，婚配统一个途径，比方/user/new这个路由以及/user/:name就是抵触的，不克不及同时注册。

这里略微提下httprouter的另一种通配符形式，就是把:换成*，也就是*name，这是一种婚配一切的形式，不经常使用，比方：

Pattern: /user/*name

 /user/gordon              婚配
 /user/you                 婚配
 /user/gordon/profile      婚配
 /user/                    婚配

由于是婚配一切的*形式，以是只需*后面的途径婚配，就是婚配的，不论途径多长，有几层，都婚配。

httprouter兼容http.Handler

经由过程下面的例子，咱们应当曾经发明，GET法子的handle，其实不是咱们认识的http.Handler，它是httprouter自界说的，相比http.Handler多了一个通配符参数的支持。

type Handle func(http.ResponseWriter, *http.Request, Params)

自界说的Handle，独一的目的就是支持通配符参数，若是你的HTTP效劳里，有些路由没有用到通配符参数，那末可使用原生的http.Handler，httprouter是兼容支持的，这也为咱们从net/http的体式格局，降级为httprouter路由提供了不便，会高效不少。

func (r *Router) Handler(method, path string, handler http.Handler) {
	r.Handle(method, path,
		func(w http.ResponseWriter, req *http.Request, _ Params) {
			handler.ServeHTTP(w, req)
		},
	)
}

func (r *Router) HandlerFunc(method, path string, handler http.HandlerFunc) {
	r.Handler(method, path, handler)
}

httprouter经由过程Handler以及HandlerFunc两个函数，提供了兼容http.Handler以及http.HandlerFunc的完满支持。从以上源代码中，咱们可以看出，完成的体式格局也比力简略，就是做了一个http.Handler到httprouter.Handle的转换，舍弃了通配符参数的支持。

Handler处置链

患上益于http.Handler的形式，咱们可以把差别的http.Handler构成一个处置链，httprouter.Router也是完成了http.Handler的，以是它也能够作为http.Handler处置链的一部份，比方以及Negroni、Gorilla handlers这两个库合营应用，对于这两个库的先容，可以参考我之前写的文章。

受中国武器进口打击的英国军器商起头裁人 男子破晓被雷电惊醒房距离断墙猛然倒

这里应用一个民间的例子，作为Handler处置链的演示。

比方对多个差别的二级域名，举行差别的路由处置。

//一个新类型，用于存储域名对应的路由
type HostSwitch map[string]http.Handler

//完成http.Handler接口，举行差别域名的路由分发
func (hs HostSwitch) ServeHTTP(w http.ResponseWriter, r *http.Request) {

    //按照域名获取对应的Handler路由，而后挪用处置（分发机制）
	if handler := hs[r.Host]; handler != nil {
		handler.ServeHTTP(w, r)
	} else {
		http.Error(w,"Forbidden", 403)
	}
}

func main() {
    //声明两个路由
	playRouter := httprouter.New()
	playRouter.GET("/", PlayIndex)
	
	toolRouter := httprouter.New()
	toolRouter.GET("/", ToolIndex)

    //别离用于处置差别的二级域名
	hs := make(HostSwitch)
	hs["play.flysnow.org:12345"] = playRouter
	hs["tool.flysnow.org:12345"] = toolRouter

    //HostSwitch完成了http.Handler,以是可以间接用
	log.Fatal(http.ListenAndServe(":12345", hs))
}

以上就是一个简略的，针对差别域名，应用差别路由的例子，代码中的正文比力具体了，这里就纷歧一诠释了。这个例子中,HostSwitch以及httprouter.Router这两个http.Handler就构成了一个http.Handler处置链。

httprouter 静态文件效劳

httprouter提供了很不便的静态文件效劳，可以把一个目次托管在效劳器上，以供拜访。

	router.ServeFiles("/static/*filepath",http.Dir("/"))

只要要这一句焦点代码便可，这个就是把以后目次托管在效劳器上，以供拜访，拜访途径是/static。

应用ServeFiles需求注重的是，第一个参数途径，必需要以/*filepath，由于要获取咱们要拜访的途径信息。

func (r *Router) ServeFiles(path string, root http.FileSystem) {
	if len(path) < 10 || path[len(path)-10:] !="/*filepath" {
		panic("path must end with /*filepath in path '" + path +"'")
	}

	fileServer := http.FileServer(root)

	r.GET(path, func(w http.ResponseWriter, req *http.Request, ps Params) {
		req.URL.Path = ps.ByName("filepath")
		fileServer.ServeHTTP(w, req)
	})
}

这是源代码完成，咱们发明，最初仍是一个GET要求效劳，经由过程http.FileServer把filepath的途径的内容显现进去（若是途径是个目次则列出目次文件；若是途径是文件，则显现内容）。

经由过程下面的源代码，咱们也能够晓得，*filepath这个通配符是为了获取要放问的文件途径，以是要合适预约，否则就会panic。

httprouter 异样捕捉

很少有路由支持这个功效的，httprouter容许应用者，配置PanicHandler用于处置HTTP要求中产生的panic。

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
	panic("成心抛出的异样")
}

func main() {
	router := httprouter.New()
	router.GET("/", Index)
	router.PanicHandler = func(w http.ResponseWriter, r *http.Request, v interface{}) {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintf(w,"error:%s",v)
	}

	log.Fatal(http.ListenAndServe(":8080", router))
}

演示例子中，咱们经由过程配置router.PanicHandler来处置产生的panic，处置措施是打印进去异样信息。而后成心在Index函数中抛出一个painc，而后咱们运转测试，会看到异样信息。

这是一种很是好的体式格局，可让咱们对painc举行同一处置，不至于由于遗漏的panic影响用户应用。

小结

httprouter另有很多有用的小功效，比方对404举行处置，咱们经由过程配置Router.NotFound来完成，咱们看看Router这个结构体的设置，可以发明更多有用的功效。

type Router struct {
    //是不是经由过程重定向，给途径自定加斜杠
	RedirectTrailingSlash bool
    //是不是经由过程重定向，自动修复途径，比方双斜杠等自动修复为单斜杠
	RedirectFixedPath bool
    //是不是检测以后要求的法子被容许
	HandleMethodNotAllowed bool
	//是不是自定回答OPTION要求
	HandleOPTIONS bool
    //404默许处置
	NotFound http.Handler
    //不被容许的法子默许处置
	MethodNotAllowed http.Handler
    //异样同一处置
	PanicHandler func(http.ResponseWriter, *http.Request, interface{})
}

这些字段都是导出的(export)，咱们可以间接配置，来到达咱们的目的。

httprouter是一个高机能，低内存占用的路由，它应用radix tree完成存储以及婚配查找，以是效力很是高，内存占用也很低。对于radix tree大师可以查看相干的资料。

httprouter由于完成了http.Handler，以是可扩大性很是好，可以以及其余库、中心件连系应用，gin这个web框架就是应用的自界说的httprouter。

颁发谈论