深刻理解Golang之http server

時間 2019-11-21

標籤深刻理解 golang http server 欄目 Go 简体版

原文原文鏈接

前言

對於Golang來講，實現一個簡單的http server很是容易，只須要短短几行代碼。同時有了協程的加持，Go實現的http server可以取得很是優秀的性能。這篇文章將會對go標準庫net/http實現http服務的原理進行較爲深刻的探究，以此來學習瞭解網絡編程的常見範式以及設計思路。html

HTTP服務

基於HTTP構建的網絡應用包括兩個端，即客戶端(Client)和服務端(Server)。兩個端的交互行爲包括從客戶端發出request、服務端接受request進行處理並返回response以及客戶端處理response。因此http服務器的工做就在於如何接受來自客戶端的request，並向客戶端返回response。golang

典型的http服務端的處理流程能夠用下圖表示：web

服務器在接收到請求時，首先會進入路由(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服務。app

註冊路由

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。tcp

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

以上。