對於Golang來說，實現一個簡單的http server非常容易，只需要短短几行代碼。同時有了協程的加持，Go實現的http server能夠取得非常優秀的性能。這篇文章將會對go標準庫net/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是一個接口：
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方法。讀者可以體會一下這種技巧。
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取代默認的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 := `
Golang
Welcome!
`
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框架，以及編寫特定功能的中間件。
以上。
本文作者：Turling_hu
首發於：https://juejin.im/post/5dd11baff265da0c0c1fe813
參考資料
【Golang標準庫文檔--net/http】 https://studygolang.com/pkg
喜歡本文的朋友，歡迎關注「Go語言中文網」：
Go語言中文網啟用微信學習交流群，歡迎加微信：274768166