前言

對於Golang來說，實現一個簡單的 http server 非常容易，只需要短短几行程式碼。同時有了協程的加持，Go實現的 http server 能夠取得非常優秀的效能。這篇文章將會對go標準庫 net/http 實現http服務的原理進行較為深入的探究，以此來學習瞭解網路程式設計的常見正規化以及設計思路。

HTTP服務

基於HTTP構建的網路應用包括兩個端，即客戶端( Client )和服務端( Server )。兩個端的互動行為包括從客戶端發出 request 、服務端接受 request 進行處理並返回 response 以及客戶端處理 response 。所以http伺服器的工作就在於如何接受來自客戶端的 request

典型的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,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,*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,"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)
}

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 框架，以及編寫特定功能的中介軟體。

以上。

參考資料

【Golang標準庫文件--net/http】

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。