前言
对于golang来说,实现一个简单的 http server
非常容易,只需要短短几行代码。同时有了协程的加持,go实现的 http server
能够取得非常优秀的性能。这篇文章将会对go标准库 net/http
实现http服务的原理进行较为深入的探究,以此来学习了解网络编程的常见范式以及设计思路。
http服务
基于http构建的网络应用包括两个端,即客户端( client
)和服务端( server
)。两个端的交互行为包括从客户端发出 request
、服务端接受 request
进行处理并返回 response
以及客户端处理 response
。所以http服务器的工作就在于如何接受来自客户端的 request
,并向客户端返回 response
。
典型的http服务端的处理流程可以用下图表示:
服务器在接收到请求时,首先会进入路由( router
),这是一个 multiplexer
,路由的工作在于为这个 request
找到对应的处理器( handler
),处理器对 request
进行处理,并构建 response
。golang实现的 http server
同样遵循这样的处理流程。
我们先看看golang如何实现一个简单的 http server
:
package main import ( "fmt" "net/http" ) func indexhandler(w http.responsewriter, r *http.request) { fmt.fprintf(w, "hello world") } func main() { http.handlefunc("/", indexhandler) http.listenandserve(":8000", nil) }
运行代码之后,在浏览器中打开 localhost:8000
就可以看到 hello world
。这段代码先利用 http.handlefunc
在根路由 /
上注册了一个 indexhandler
, 然后利用 http.listenandserve
开启监听。当有请求过来时,则根据路由执行对应的 handler
函数。
我们再来看一下另外一种常见的 http server
实现方式:
package main import ( "fmt" "net/http" ) type indexhandler struct { content string } func (ih *indexhandler) servehttp(w http.responsewriter, r *http.request) { fmt.fprintf(w, ih.content) } func main() { http.handle("/", &indexhandler{content: "hello world!"}) http.listenandserve(":8001", nil) }
go实现的 http
服务步骤非常简单,首先注册路由,然后创建服务并开启监听即可。下文我们将从注册路由、开启服务、处理请求这几个步骤了解golang如何实现 http
服务。
注册路由
http.handlefunc
和 http.handle
都是用于注册路由,可以发现两者的区别在于第二个参数,前者是一个具有 func(w http.responsewriter, r *http.requests)
签名的函数,而后者是一个结构体,该结构体实现了 func(w http.responsewriter, r *http.requests)
签名的方法。
http.handlefunc
和 http.handle
的源码如下:
func handlefunc(pattern string, handler func(responsewriter, *request)) { defaultservemux.handlefunc(pattern, handler) } // handlefunc registers the handler function for the given pattern. func (mux *servemux) handlefunc(pattern string, handler func(responsewriter, *request)) { if handler == nil { panic("http: nil handler") } mux.handle(pattern, handlerfunc(handler)) }
func handle(pattern string, handler handler) { defaultservemux.handle(pattern, handler) }
可以看到这两个函数最终都由 defaultservemux
调用 handle
方法来完成路由的注册。
这里我们遇到两种类型的对象: servemux
和 handler
,我们先说 handler
。
handler
handler
是一个接口:
type handler interface { servehttp(responsewriter, *request) }
handler
接口中声明了名为 servehttp
的函数签名,也就是说任何结构只要实现了这个 servehttp
方法,那么这个结构体就是一个 handler
对象。其实go的 http
服务都是基于 handler
进行处理,而 handler
对象的 servehttp
方法也正是用以处理 request
并构建 response
的核心逻辑所在。
回到上面的 handlefunc
函数,注意一下这行代码:
mux.handle(pattern, handlerfunc(handler))
可能有人认为 handlerfunc
是一个函数,包装了传入的 handler
函数,返回了一个 handler
对象。然而这里 handlerfunc
实际上是将 handler
函数做了一个 类型转换 ,看一下 handlerfunc
的定义:
type handlerfunc func(responsewriter, *request) // servehttp calls f(w, r). func (f handlerfunc) servehttp(w responsewriter, r *request) { f(w, r) }
handlerfunc
是一个类型,只不过表示的是一个具有 func(responsewriter, *request)
签名的函数类型,并且这种类型实现了 servehttp
方法(在 servehttp
方法中又调用了自身),也就是说这个类型的函数其实就是一个 handler
类型的对象。利用这种类型转换,我们可以将一个 handler
函数转换为一个
handler
对象,而不需要定义一个结构体,再让这个结构实现 servehttp
方法。读者可以体会一下这种技巧。
servemux
golang中的路由(即 multiplexer
)基于 servemux
结构,先看一下 servemux
的定义:
type servemux struct { mu sync.rwmutex m map[string]muxentry es []muxentry // slice of entries sorted from longest to shortest. hosts bool // whether any patterns contain hostnames } type muxentry struct { h handler pattern string }
这里重点关注 servemux
中的字段 m
,这是一个 map
, key
是路由表达式, value
是一个 muxentry
结构, muxentry
结构体存储了对应的路由表达式和 handler
。
值得注意的是, servemux
也实现了 servehttp
方法:
func (mux *servemux) servehttp(w responsewriter, r *request) { if r.requesturi == "*" { if r.protoatleast(1, 1) { w.header().set("connection", "close") } w.writeheader(statusbadrequest) return } h, _ := mux.handler(r) h.servehttp(w, r) }
也就是说 servemux
结构体也是 handler
对象,只不过 servemux
的 servehttp
方法不是用来处理具体的 request
和构建 response
,而是用来确定路由注册的 handler
。
注册路由
搞明白 handler
和 servemux
之后,我们再回到之前的代码:
defaultservemux.handle(pattern, handler)
这里的 defaultservemux
表示一个默认的 multiplexer
,当我们没有创建自定义的 multiplexer
,则会自动使用一个默认的 multiplexer
。
然后再看一下 servemux
的 handle
方法具体做了什么:
func (mux *servemux) handle(pattern string, handler handler) { mux.mu.lock() defer mux.mu.unlock() if pattern == "" { panic("http: invalid pattern") } if handler == nil { panic("http: nil handler") } if _, exist := mux.m[pattern]; exist { panic("http: multiple registrations for " + pattern) } if mux.m == nil { mux.m = make(map[string]muxentry) } // 利用当前的路由和handler创建muxentry对象 e := muxentry{h: handler, pattern: pattern} // 向servemux的map[string]muxentry增加新的路由匹配规则 mux.m[pattern] = e // 如果路由表达式以'/'结尾,则将对应的muxentry对象加入到[]muxentry中,按照路由表达式长度排序 if pattern[len(pattern)-1] == '/' { mux.es = appendsorted(mux.es, e) } if pattern[0] != '/' { mux.hosts = true } }
handle
方法主要做了两件事情:一个就是向 servemux
的 map[string]muxentry
增加给定的路由匹配规则;然后如果路由表达式以 '/'
结尾,则将对应的 muxentry
对象加入到 []muxentry
中,按照路由表达式长度排序。前者很好理解,但后者可能不太容易看出来有什么作用,这个问题后面再作分析。
自定义servemux
我们也可以创建自定义的 servemux
取代默认的 defaultservemux
:
package main import ( "fmt" "net/http" ) func indexhandler(w http.responsewriter, r *http.request) { fmt.fprintf(w, "hello world") } func htmlhandler(w http.responsewriter, r *http.request) { w.header().set("content-type", "text/html") html := `<!doctype html> <meta http-equiv="content-type" content="text/html" charset="utf-8"> <html lang="zh-cn"> <head> <title>golang</title> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0;" /> </head> <body> <div id="app">welcome!</div> </body> </html>` fmt.fprintf(w, html) } func main() { mux := http.newservemux() mux.handle("/", http.handlerfunc(indexhandler)) mux.handlefunc("/welcome", htmlhandler) http.listenandserve(":8001", mux) }
newservemux()
可以创建一个 servemux
实例,之前提到 servemux
也实现了 servehttp
方法,因此 mux
也是一个 handler
对象。对于 listenandserve()
方法,如果传入的 handler
参数是自定义 servemux
实例 mux
,那么 server
实例接收到的路由对象将不再是 defaultservemux
而是 mux
。
开启服务
首先从 http.listenandserve
这个方法开始:
func listenandserve(addr string, handler handler) error { server := &server{addr: addr, handler: handler} return server.listenandserve() } func (srv *server) listenandserve() error { if srv.shuttingdown() { return errserverclosed } addr := srv.addr if addr == "" { addr = ":http" } ln, err := net.listen("tcp", addr) if err != nil { return err } return srv.serve(tcpkeepalivelistener{ln.(*net.tcplistener)}) }
这里先创建了一个 server
对象,传入了地址和 handler
参数,然后调用 server
对象 listenandserve()
方法。
看一下 server
这个结构体, server
结构体中字段比较多,可以先大致了解一下:
type server struct { addr string // tcp address to listen on, ":http" if empty handler handler // handler to invoke, http.defaultservemux if nil tlsconfig *tls.config readtimeout time.duration readheadertimeout time.duration writetimeout time.duration idletimeout time.duration maxheaderbytes int tlsnextproto map[string]func(*server, *tls.conn, handler) connstate func(net.conn, connstate) errorlog *log.logger disablekeepalives int32 // accessed atomically. inshutdown int32 // accessed atomically (non-zero means we're in shutdown) nextprotoonce sync.once // guards setuphttp2_* init nextprotoerr error // result of http2.configureserver if used mu sync.mutex listeners map[*net.listener]struct{} activeconn map[*conn]struct{} donechan chan struct{} onshutdown []func() }
在 server
的 listenandserve
方法中,会初始化监听地址 addr
,同时调用 listen
方法设置监听。最后将监听的tcp对象传入 serve
方法:
func (srv *server) serve(l net.listener) error { ... basectx := context.background() // base is always background, per issue 16220 ctx := context.withvalue(basectx, servercontextkey, srv) for { rw, e := l.accept() // 等待新的连接建立 ... c := srv.newconn(rw) c.setstate(c.rwc, statenew) // before serve can return go c.serve(ctx) // 创建新的协程处理请求 } }
这里隐去了一些细节,以便了解 serve
方法的主要逻辑。首先创建一个上下文对象,然后调用 listener
的 accept()
等待新的连接建立;一旦有新的连接建立,则调用 server
的 newconn()
创建新的连接对象,并将连接的状态标志为 statenew
,然后开启一个新的 goroutine
处理连接请求。
处理连接
我们继续探索 conn
的 serve()
方法,这个方法同样很长,我们同样只看关键逻辑。坚持一下,马上就要看见大海了。
func (c *conn) serve(ctx context.context) { ... for { w, err := c.readrequest(ctx) if c.r.remain != c.server.initialreadlimitsize() { // if we read any bytes off the wire, we're active. c.setstate(c.rwc, stateactive) } ... // http cannot have multiple simultaneous active requests.[*] // until the server replies to this request, it can't read another, // so we might as well run the handler in this goroutine. // [*] not strictly true: http pipelining. we could let them all process // in parallel even if their responses need to be serialized. // but we're not going to implement http pipelining because it // was never deployed in the wild and the answer is http/2. serverhandler{c.server}.servehttp(w, w.req) w.cancelctx() if c.hijacked() { return } w.finishrequest() if !w.shouldreuseconnection() { if w.requestbodylimithit || w.closedrequestbodyearly() { c.closewriteandwait() } return } c.setstate(c.rwc, stateidle) // 请求处理结束后,将连接状态置为空闲 c.curreq.store((*response)(nil))// 将当前请求置为空 ... } }
当一个连接建立之后,该连接中所有的请求都将在这个协程中进行处理,直到连接被关闭。在 serve()
方法中会循环调用 readrequest()
方法读取下一个请求进行处理,其中最关键的逻辑就是一行代码:
serverhandler{c.server}.servehttp(w, w.req)
进一步解释 serverhandler
:
type serverhandler struct { srv *server } func (sh serverhandler) servehttp(rw responsewriter, req *request) { handler := sh.srv.handler if handler == nil { handler = defaultservemux } if req.requesturi == "*" && req.method == "options" { handler = globaloptionshandler{} } handler.servehttp(rw, req) }
在 serverhandler
的 servehttp()
方法里的 sh.srv.handler
其实就是我们最初在 http.listenandserve()
中传入的 handler
对象,也就是我们自定义的 servemux
对象。如果该 handler
对象为 nil
,则会使用默认的 defaultservemux
。最后调用 servemux
的 servehttp()
方法匹配当前路由对应的 handler
方法。
后面的逻辑就相对简单清晰了,主要在于调用 servemux
的 match
方法匹配到对应的已注册的路由表达式和 handler
。
// servehttp dispatches the request to the handler whose // pattern most closely matches the request url. func (mux *servemux) servehttp(w responsewriter, r *request) { if r.requesturi == "*" { if r.protoatleast(1, 1) { w.header().set("connection", "close") } w.writeheader(statusbadrequest) return } h, _ := mux.handler(r) h.servehttp(w, r) } func (mux *servemux) handler(host, path string) (h handler, pattern string) { mux.mu.rlock() defer mux.mu.runlock() // host-specific pattern takes precedence over generic ones if mux.hosts { h, pattern = mux.match(host + path) } if h == nil { h, pattern = mux.match(path) } if h == nil { h, pattern = notfoundhandler(), "" } return } // find a handler on a handler map given a path string. // most-specific (longest) pattern wins. func (mux *servemux) match(path string) (h handler, pattern string) { // check for exact match first. v, ok := mux.m[path] if ok { return v.h, v.pattern } // check for longest valid match. mux.es contains all patterns // that end in / sorted from longest to shortest. for _, e := range mux.es { if strings.hasprefix(path, e.pattern) { return e.h, e.pattern } } return nil, "" }
在 match
方法里我们看到之前提到的 map[string]muxentry
和 []muxentry
。这个方法里首先会利用进行精确匹配,在 map[string]muxentry
中查找是否有对应的路由规则存在;如果没有匹配的路由规则,则会进行近似匹配。
对于类似 /path1/path2/path3
这样的路由,如果不能找到精确匹配的路由规则,那么则会去匹配和当前路由最接近的已注册的父路由,所以如果路由 /path1/path2/
已注册,那么该路由会被匹配,否则继续匹配父路由,知道根路由 /
。
由于 []muxentry
中的 muxentry
按照路由表达是从长到短排序,所以进行近似匹配时匹配到的路由一定是已注册父路由中最接近的。
至此,go实现的 http server
的大致原理介绍完毕!
总结
golang通过 servemux
定义了一个多路器来管理路由,并通过 handler
接口定义了路由处理函数的统一规范,即 handler
都须实现 servehttp
方法;同时 handler
接口提供了强大的扩展性,方便开发者通过 handler
接口实现各种中间件。相信大家阅读下来也能感受到 handler
对象在 server
服务的实现中真的无处不在。理解了 server
实现的基本原理,大家就可以在此基础上阅读一些第三方的 http server
框架,以及编写特定功能的中间件。
以上。
参考资料
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持移动技术网。
如对本文有疑问, 点击进行留言回复!!
网友评论