本位為http的源碼分析，如果在此之前你還不知道如何使用 golang 的 http 庫，建議先看一個入門的例子：快速入門：創建第一個 Go Web 應用 | 快速入門 | Go Web 編程 (laravelacademy.org)
本文轉載自：Go Web 編程入門--深入學習用 Go 編寫 HTTP 服務器 | Go 技術論壇 (learnku.com)
前言
Go 是一門通用的編程語言，想要學習 Go 語言的 Web 開發，就必須知道如何用 Go 啟動一個 HTTP 服務器用於接收和響應來自客戶端的 HTTP 請求。用 Go 實現一個 http server 非常容易，Go 語言標准庫 net/http 自帶了一系列結構和方法來幫助開發者簡化 HTTP 服務開發的相關流程。因此，我們不需要依賴任何第三方組件就能構建並啟動一個高並發的 HTTP 服務器。這篇文章會學習如何用 net/http 自己編寫實現一個 HTTP Server 並探究其實現原理，以此來學習了解網絡編程的常見范式以及設計思路。
HTTP 服務處理流程
基於 HTTP 構建的服務標准模型包括兩個端，客戶端 (Client) 和服務端 (Server)。HTTP 請求從客戶端發出，服務端接受到請求后進行處理然后將響應返回給客戶端。所以 http 服務器的工作就在於如何接受來自客戶端的請求，並向客戶端返回響應。
典型的 HTTP 服務的處理流程如下圖所示：
服務器在接收到請求時，首先會進入路由 (router)，也成為服務復用器（Multiplexe），路由的工作在於請求找到對應的處理器 (handler)，處理器對接收到的請求進行相應處理后構建響應並返回給客戶端。Go 實現的 http server 同樣遵循這樣的處理流程。
我們先看看 Go 如何實現一個簡單的返回 "Hello World" 的 http server：
package main import ( "fmt" "net/http" ) func HelloHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello World") } func main () { http.HandleFunc("/", HelloHandler) http.ListenAndServe(":8000", nil) }運行代碼之后，在瀏覽器中打開 localhost:8000 就可以看到 Hello World。這段代碼先利用 http.HandleFunc 在根路由 / 上注冊了一個 HelloHandler, 然后利用 http.ListenAndServe 啟動服務器並監聽本地的 8000 端口。當有請求過來時，則根據路由執行對應的 handler 函數。
注意：http.ListenAndServe(":8000", nil) 的第一個參數本來應該是 ip: 端口號 的形式，但是這里省略了ip，那么默認為 0.0.0.0。因為根據源碼一路可以追蹤到：
我們再看一下另外一種常見的實現方式：
package main import ( "fmt" "net/http" ) type HelloHandlerStruct struct { content string } func (handler *HelloHandlerStruct) ServeHTTP(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, handler.content) } func main() { http.Handle("/", &HelloHandlerStruct{content: "Hello World"}) http.ListenAndServe(":8000", nil) }這段代碼不再使用 http.HandleFunc 函數，取而代之的是直接調用 http.Handle 並傳入我們自定義的 http.Handler 接口的實例。
Go 實現的 http 服務步驟非常簡單，首先注冊路由，然后創建服務並開啟監聽即可。下文我們將從注冊路由、開啟服務、處理請求，以及關閉服務這幾個步驟了解 Go 如何實現 http 服務。
路由注冊
http.HandleFunc 和 http.Handle 都是用於給路由規則指定處理器，http.HandleFunc 的第一個參數為路由的匹配規則 (pattern) 第二個參數是一個簽名為 func(w http.ResponseWriter, r *http.Requests) 的函數。而 http.Handle 的第二個參數為實現了 http.Handler 接口的類型的實例。
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
http.Handler 是 net/http 中定義的接口用來表示 HTTP 請求：
type Handler interface { ServeHTTP(ResponseWriter, *Request) }Handler 接口中聲明了名為 ServeHTTP 的函數簽名，也就是說任何結構只要實現了這個 ServeHTTP 方法，那么這個結構體就是一個 Handler 對象。其實 go 的 http 服務都是基於 Handler 進行處理，而 Handler 對象的 ServeHTTP 方法會讀取 Request 進行邏輯處理然后向 ResponseWriter 中寫入響應的頭部信息和響應內容。
回到上面的 HandleFunc 函數，它調用了 *ServeMux.HandleFunc 將處理器注冊到指定路由規則上：
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) { if handler == nil { panic("http: nil handler") } mux.Handle(pattern, HandlerFunc(handler)) }注意一下這行代碼：
mux.Handle(pattern, HandlerFunc(handler))這里 HandlerFunc 實際上是將 handler 函數做了一個類型轉換，將函數轉換為了 http.HandlerFunc 類型（注意：注冊路由時調用的是 http.HandleFunc，這里類型是 http.HandlerFunc）。看一下 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 類型的對象。利用這種類型轉換，我們可以將將具有 func(ResponseWriter, *Request) 簽名的普通函數轉換為一個 Handler 對象，而不需要定義一個結構體，再讓這個結構實現 ServeHTTP 方法。
ServeMux (服務復用器)
上面的代碼中可以看到不論是使用 http.HandleFunc 還是 http.Handle 注冊路由的處理函數時最后都會用到 ServerMux 結構的 Handle 方法去注冊路由處理函數。
我們先來看一下 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。字段 m 對應的 map 用於路由的精確匹配而 es 字段的 slice 會用於路由的部分匹配，這個到了路由匹配部分再細講。
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 對象，再去調用路由處理器的 ServeHTTP 方法去處理 request 和構建 reponse。
注冊路由
搞明白 Handler 和 ServeMux 之后，我們再回到之前的代碼：
DefaultServeMux.Handle(pattern, handler)這里的 DefaultServeMux 表示一個默認的 ServeMux 實例，在上面的例子中我們沒有創建自定義的 ServeMux，所以會自動使用 DefaultServeMux
然后再看一下 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") } // 路由已經注冊過處理器函數，直接panic if _, exist := mux.m[pattern]; exist { panic("http: multiple registrations for " + pattern) } if mux.m == nil { mux.m = make(map[string]muxEntry) } // 用路由的pattern和處理函數創建 muxEntry 對象 e := muxEntry{h: handler, pattern: pattern} // 向ServeMux的m 字段增加新的路由匹配規則 mux.m[pattern] = e if pattern[len(pattern)-1] == '/' { // 如果路由patterm以'/'結尾，則將對應的muxEntry對象加入到[]muxEntry中，路由長的位於切片的前面 mux.es = appendSorted(mux.es, e) } if pattern[0] != '/' { mux.hosts = true } }Handle 方法注冊路由時主要做了兩件事情：一個就是向 ServeMux 的 map[string]muxEntry 增加給定的路由匹配規則；然后如果路由表達式以'/' 結尾，則將對應的 muxEntry 對象加入到 []muxEntry 中，按照路由表達式長度倒序排列。前者用於路由精確匹配，后者用於部分匹配，具體怎么匹配的后面再看。
自定義 ServeMux
通過 http.NewServeMux() 可以創建一個 ServeMux 實例取代默認的 DefaultServeMux
我們把上面輸出 Hello World 的 http server 再次改造一下，使用自定義的 ServeMux 實例作為 ListenAndServe() 方法的第二個參數，並且增加一個 /welcome 路由（下面的代碼主要是展示用 Handle 和 HandleFunc 注冊路由，實際使用的時候不必這么麻煩，選一種就好）：
package main import ( "fmt" "net/http" ) type WelcomeHandlerStruct struct { } func HelloHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello World") } func (*WelcomeHandlerStruct) ServeHTTP(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Welcome") } func main () { mux := http.NewServeMux() mux.HandleFunc("/", HelloHandler) mux.Handle("/welcome", &WelcomeHandlerStruct{}) http.ListenAndServe(":8080", mux) }之前提到 ServeMux 也實現了 ServeHTTP 方法，因此 mux 也是一個 Handler 對象。對於 ListenAndServe() 方法，如果第二個參數是自定義 ServeMux 實例，那么 Server 實例接收到的 ServeMux 服務復用器對象將不再是 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 參數（這里的 handler 參數時 ServeMux 實例），然后調用 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 nextProtoOnce sync.Once nextProtoErr error mu sync.Mutex listeners map[*net.Listener]struct{} activeConn map[*conn]struct{}// 活躍連接 doneChan chan struct{} onShutdown []func() }在 Server 的 ListenAndServe 方法中，會初始化監聽地址 Addr，同時調用 Listen 方法設置監聽。最后將監聽的 TCP 對象傳入其 Serve 方法。Server 對象的 Serve 方法會接收 Listener 中過來的連接，為每個連接創建一個 goroutine，在 goroutine 中會用路由處理 Handler 對請求進行處理並構建響應。
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()// 接收 listener 過來的網絡連接請求 ...... c := srv.newConn(rw) c.setState(c.rwc, StateNew) // 將連接放在 Server.activeConn這個 map 中 go c.serve(ctx)// 創建協程處理請求 } }這里隱去了一些細節，以便了解 Serve 方法的主要邏輯。首先創建一個上下文對象，然后調用 Listener 的 Accept() 接收監聽到的網絡連接；一旦有新的連接建立，則調用 Server 的 newConn() 創建新的連接對象，並將連接的狀態標志為 StateNew，然后開啟一個 goroutine 處理連接請求。
處理連接
在開啟的 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) } ... 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 是一個結構體類型，它會代理 Server 對象：
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 方法。
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(r *Request) (h Handler, pattern string) { if r.Method == "CONNECT" { if u, ok := mux.redirectToPathSlash(r.URL.Host, r.URL.Path, r.URL); ok { return RedirectHandler(u.String(), StatusMovedPermanently), u.Path } return mux.handler(r.Host, r.URL.Path) } // All other requests have any port stripped and path cleaned // before passing to mux.handler. host := stripHostPort(r.Host) path := cleanPath(r.URL.Path) // If the given path is /tree and its handler is not registered, // redirect for /tree/. if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok { return RedirectHandler(u.String(), StatusMovedPermanently), u.Path } if path != r.URL.Path { _, pattern = mux.handler(host, path) url := *r.URL url.Path = path return RedirectHandler(url.String(), StatusMovedPermanently), pattern } return mux.handler(host, r.URL.Path) } // handler is the main implementation of Handler. // The path is known to be in canonical form, except for CONNECT methods. 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