--------------------------------
深入理解Golang之http server
前言
對於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
方法裏我們看到之前提到的mux的m
字段(類型爲map[string]muxEntry
)和es
(類型爲[]muxEntry
)。這個方法裏首先會利用進行精確匹配,在map[string]muxEntry
中查找是否有對應的路由規則存在;如果沒有匹配的路由規則,則會利用es
進行近似匹配。
之前提到在註冊路由時會把以'/'
結尾的路由(可稱爲節點路由)加入到es
字段的[]muxEntry
中。對於類似/path1/path2/path3
這樣的路由,如果不能找到精確匹配的路由規則,那麼則會去匹配和當前路由最接近的已註冊的父節點路由,所以如果路由/path1/path2/
已註冊,那麼該路由會被匹配,否則繼續匹配下一個父節點路由,直到根路由/
。
由於[]muxEntry
中的muxEntry
按照路由表達式從長到短排序,所以進行近似匹配時匹配到的節點路由一定是已註冊父節點路由中最相近的。
至此,Go實現的http server
的大致原理介紹完畢!
總結
Golang通過ServeMux
定義了一個多路器來管理路由,並通過Handler
接口定義了路由處理函數的統一規範,即Handler
都須實現ServeHTTP
方法;同時Handler
接口提供了強大的擴展性,方便開發者通過Handler
接口實現各種中間件。相信大家閱讀下來也能感受到Handler
對象在server
服務的實現中真的無處不在。理解了server
實現的基本原理,大家就可以在此基礎上閱讀一些第三方的http server
框架,以及編寫特定功能的中間件。
以上。