深入理解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")
}
main() {
http.HandleFunc("/", indexHandler)
http.ListenAndServe(":8000", nil)
}
複製程式碼執行程式碼之後，在瀏覽器中開啟localhost:8000就可以看到hello world。這段程式碼先利用http.HandleFunc在根路由/上註冊了一個indexHandler,然後利用http.ListenAndServe開啟監聽。當有請求過來時，則根據路由執行對應的handler函式。
我們再來看一下另外一種常見的http server實現方式：
"net/http"
)
type indexHandler struct {
content string
}
func (ih *indexHandler) ServeHTTP(w http.ResponseWriter, ih.content)
}
main() {
http.Handle("hello world!"})
http.ListenAndServe(":8001",128); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-literal">nil)
}
複製程式碼Go實現的http服務步驟非常簡單，首先註冊路由，然後建立服務並開啟監聽即可。下文我們將從註冊路由、開啟服務、處理請求這幾個步驟瞭解Golang如何實現http服務。
註冊路由
http.HandleFunc和http.Handle都是用於註冊路由，可以發現兩者的區別在於第二個引數，前者是一個具有func(w http.ResponseWriter,r *http.Requests)簽名的函式，而後者是一個結構體，該結構體實現了http.Handle的原始碼如下：
HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
// HandleFunc registers the handler function for the given pattern.
func (mux *ServeMux) if handler == nil {
panic("http: nil handler")
}
mux.Handle(pattern, HandlerFunc(handler))
}
複製程式碼Handle(pattern 複製程式碼可以看到這兩個函式最終都由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方法：
if r.RequestURI == "*" {
if r.ProtoAtLeast(1,128); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-number">1) {
w.Header().Set("Connection",68); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-string">"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。
然後再看一下Handle方法具體做了什麼：
defer mux.mu.Unlock()
if pattern == "" {
"http: invalid pattern")
}
"http: nil handler")
}
if _, exist := mux.m[pattern]; exist {
"http: multiple registrations for " + pattern)
}
if mux.m == nil {
mux.m = make(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)
}
0] != '/' {
mux.hosts = true
}
}
複製程式碼Handle方法主要做了兩件事情：一個就是向map[string]muxEntry增加給定的路由匹配規則；然後如果路由表示式以'/'結尾，則將對應的muxEntry物件加入到[]muxEntry中，按照路由表示式長度排序。前者很好理解，但後者可能不太容易看出來有什麼作用，這個問題後面再作分析。
自定義ServeMux
我們也可以建立自定義的ServeMux取代預設的DefaultServeMux：
htmlHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type",68); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-string">"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)
}
main() {
mux := http.NewServeMux()
mux.Handle("/welcome", htmlHandler)
http.ListenAndServe(複製程式碼NewServeMux()可以建立一個ServeMux例項，之前提到ServeHTTP方法，因此mux也是一個Handler物件。對於ListenAndServe()方法，如果傳入的handler引數是自定義ServeMux例項mux，那麼Server例項接收到的路由物件將不再是DefaultServeMux而是mux。
開啟服務
首先從http.ListenAndServe這個方法開始：
ListenAndServe(addr 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 string]func(*Server, *tls.Conn, Handler)
ConnState func(net.Conn, ConnState)
ErrorLog *log.Logger
disableKeepAlives int32 // accessed atomically.
inShutdown atomically (non-zero means we're in Shutdown)
nextProtoOnce sync.Once // guards setupHTTP2_* init
nextProtoErr error // result of http2.ConfigureServer if used
mu Mutex
listeners map[*net.Listener]struct{}
activeConn map[*conn]struct{}
doneChan chan struct{}
onShutdown []func()
}
複製程式碼在Server的ListenAndServe方法中，會初始化監聽地址Addr，同時呼叫Listen方法設定監聽。最後將監聽的TCP物件傳入Serve方法：
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()等待新的連線建立；一旦有新的連線建立，則呼叫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
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。最後呼叫ServeHTTP()方法匹配當前路由對應的handler方法。
後面的邏輯就相對簡單清晰了，主要在於呼叫match方法匹配到對應的已註冊的路由表示式和handler。
// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
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)
}
""
}
return
}
// Find a handler on a handler map given a path string.
// Most-specific (longest) pattern wins.
match(path 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,68); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-string">""
}
複製程式碼在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框架，以及編寫特定功能的中介軟體。
以上。