一日一學_Go語言HTTP Server(源碼分析)

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

Go語言中HTTP Server:

HTTP server，顧名思義，支援http協議的伺服器，HTTP是一個簡單的要求-回應協議，通常運行在TCP之上。通過用戶端發送請求給伺服器得到對應的響應。

HTTP

HTTP服務簡單實現

package mainimport (    "fmt"    "net/http")//③處理請求，返回結果func Hello(w http.ResponseWriter, r *http.Request) {    fmt.Fprintln(w, "hello world")}func main() {    //①路由註冊    http.HandleFunc("/", Hello)     //②服務監聽    http.ListenAndServe(":8080", nil)}

你以為這樣就結束了嗎，不才剛剛開始。

源碼分析

①路由註冊
http中的HandleFunc方法,主要用來註冊路由

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {    DefaultServeMux.HandleFunc(pattern, handler)}

DefaultServeMux是什嗎？
DefaultServeMux是ServeMux的一個執行個體。
ServeMux又是什嗎？

// DefaultServeMux is the default ServeMux used by Serve.var DefaultServeMux = &defaultServeMuxvar defaultServeMux ServeMuxtype ServeMux struct {    mu    sync.RWMutex    m     map[string]muxEntry    hosts bool }type muxEntry struct {    explicit bool    h        Handler    pattern  string}

ServeMux主要通過map[string]muxEntry，來儲存了具體的url模式和handler（此handler是實現Handler介面的類型）。通過實現Handler的ServeHTTP方法，來匹配路由（這一點下面源碼會講到）
很多地方都涉及到了Handler,那麼Handler是什嗎？

type Handler interface {    ServeHTTP(ResponseWriter, *Request)}

此介面可以算是HTTP Server一個樞紐

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {    mux.Handle(pattern, HandlerFunc(handler))}type HandlerFunc func(ResponseWriter, *Request)func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {    f(w, r)}

從代碼中可以看出HandlerFunc是一個函數類型，並實現了Handler介面。當通過調用HandleFunc()，把Hello強轉為HandlerFunc類型時，就意味著 Hello函數也實現ServeHTTP方法。
ServeMux的Handle方法:

func (mux *ServeMux) Handle(pattern string, handler Handler) {    mux.mu.Lock()    defer mux.mu.Unlock()    if pattern == "" {        panic("http: invalid pattern " + pattern)    }    if handler == nil {        panic("http: nil handler")    }    if mux.m[pattern].explicit {        panic("http: multiple registrations for " + pattern)    }    if mux.m == nil {        mux.m = make(map[string]muxEntry)    }    //把handler和pattern模式綁定到    //map[string]muxEntry的map上    mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}    if pattern[0] != '/' {        mux.hosts = true    }   //這裡是綁定靜態目錄，不作為本片重點。    n := len(pattern)    if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit {        path := pattern        if pattern[0] != '/' {            path = pattern[strings.Index(pattern, "/"):]        }        url := &url.URL{Path: path}        mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern}    }}

上面的流程就完成了路由註冊。
②服務監聽

type Server struct {    Addr         string            Handler      Handler           ReadTimeout  time.Duration     WriteTimeout time.Duration     TLSConfig    *tls.Config       MaxHeaderBytes int    TLSNextProto map[string]func(*Server, *tls.Conn, Handler)    ConnState func(net.Conn, ConnState)    ErrorLog *log.Logger    disableKeepAlives int32        nextProtoOnce     sync.Once     nextProtoErr      error     }func ListenAndServe(addr string, handler Handler) error {    server := &Server{Addr: addr, Handler: handler}    return server.ListenAndServe()}//初始化監聽地址Addr，同時調用Listen方法設定監聽。//最後將監聽的TCP對象傳入Serve方法：func (srv *Server) ListenAndServe() error {        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)})    }

Serve(l net.Listener)為每個請求開啟goroutine的設計，保證了go的高並發。

func (srv *Server) Serve(l net.Listener) error {    defer l.Close()    if fn := testHookServerServe; fn != nil {        fn(srv, l)    }    var tempDelay time.Duration // how long to sleep on accept failure    if err := srv.setupHTTP2_Serve(); err != nil {        return err    }    srv.trackListener(l, true)    defer srv.trackListener(l, false)    baseCtx := context.Background() // base is always background, per Issue 16220    ctx := context.WithValue(baseCtx, ServerContextKey, srv)    ctx = context.WithValue(ctx, LocalAddrContextKey, l.Addr())    //開啟迴圈進行監聽    for {       //通過Listener的Accept方法用來擷取串連資料        rw, e := l.Accept()        if e != nil {            select {            case <-srv.getDoneChan():                return ErrServerClosed            default:            }            if ne, ok := e.(net.Error); ok && ne.Temporary() {                if tempDelay == 0 {                    tempDelay = 5 * time.Millisecond                } else {                    tempDelay *= 2                }                if max := 1 * time.Second; tempDelay > max {                    tempDelay = max                }                srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)                time.Sleep(tempDelay)                continue            }            return e        }        tempDelay = 0        //通過獲得的串連資料，建立newConn連線物件        c := srv.newConn(rw)                c.setState(c.rwc, StateNew) // before Serve can return       //開啟goroutine發送串連請求        go c.serve(ctx)    }}

serve()為核心,讀取對應的串連資料進行分配

func (c *conn) serve(ctx context.Context) {    c.remoteAddr = c.rwc.RemoteAddr().String()        //串連關閉相關的處理    defer func() {        if err := recover(); err != nil && err != ErrAbortHandler {            const size = 64 << 10            buf := make([]byte, size)            buf = buf[:runtime.Stack(buf, false)]            c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)        }        if !c.hijacked() {            c.close()            c.setState(c.rwc, StateClosed)        }    }()    .....    ctx, cancelCtx := context.WithCancel(ctx)    c.cancelCtx = cancelCtx    defer cancelCtx()    c.r = &connReader{conn: c}    c.bufr = newBufioReader(c.r)    c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)    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)        }                .................        //處理網路資料的狀態        // Expect 100 Continue support        req := w.req        if req.expectsContinue() {            if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {                // Wrap the Body reader with one that replies on the connection                req.Body = &expectContinueReader{readCloser: req.Body, resp: w}            }        } else if req.Header.get("Expect") != "" {            w.sendExpectationFailed()            return        }        c.curReq.Store(w)        if requestBodyRemains(req.Body) {            registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)        } else {            if w.conn.bufr.Buffered() > 0 {                w.conn.r.closeNotifyFromPipelinedRequest()            }            w.conn.r.startBackgroundRead()        }        //調用serverHandler{c.server}.ServeHTTP(w, w.req)        //方法處理請求        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))        if !w.conn.server.doKeepAlives() {            return        }        if d := c.server.idleTimeout(); d != 0 {            c.rwc.SetReadDeadline(time.Now().Add(d))            if _, err := c.bufr.Peek(4); err != nil {                return            }        }        c.rwc.SetReadDeadline(time.Time{})    }}

//③處理請求，返回結果
serverHandler 主要初始化路由多工器。如果server對象沒有指定Handler，則使用預設的DefaultServeMux作為路由多工器。並調用初始化Handler的ServeHTTP方法。

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)}

這裡就是之前提到的匹配路由的具體代碼

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    }    //匹配註冊到路由上的handler函數    h, _ := mux.Handler(r)    //調用handler函數的ServeHTTP方法    //即Hello函數，然後把資料寫到http.ResponseWriter    //對象中返回給用戶端。    h.ServeHTTP(w, r)}func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {    if r.Method != "CONNECT" {        if p := cleanPath(r.URL.Path); p != r.URL.Path {            _, pattern = mux.handler(r.Host, p)            url := *r.URL            url.Path = p            return RedirectHandler(url.String(), StatusMovedPermanently), pattern        }    }    return mux.handler(r.Host, r.URL.Path)}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 {        //如 127.0.0.1/hello        h, pattern = mux.match(host + path)    }    if h == nil {        // 如  /hello        h, pattern = mux.match(path)    }    if h == nil {        h, pattern = NotFoundHandler(), ""    }    return}func (mux *ServeMux) match(path string) (h Handler, pattern string) {    var n = 0    for k, v := range mux.m {        if !pathMatch(k, path) {            continue        }      //通過迭代m尋找出註冊路由的patten模式      //與實際url匹配的handler函數並返回。        if h == nil || len(k) > n {            n = len(k)            h = v.h            pattern = v.pattern        }    }    return}func pathMatch(pattern, path string) bool {    if len(pattern) == 0 {        // should not happen        return false    }    n := len(pattern)        //如果註冊模式與請求uri一樣返回true，否則false    if pattern[n-1] != '/' {        return pattern == path    }        //靜態檔案匹配    return len(path) >= n && path[0:n] == pattern}

將資料寫給用戶端

//主要代碼，通過層層封裝才走到這一步func (w checkConnErrorWriter) Write(p []byte) (n int, err error) {    n, err = w.c.rwc.Write(p)    if err != nil && w.c.werr == nil {        w.c.werr = err        w.c.cancelCtx()    }    return}

serverHandler{c.server}.ServeHTTP(w, w.req)當請求結束後，就開始執行串連斷開的相關邏輯。

總結
Go語言通過一個ServeMux實現了的路由多工器來管理路由。同時提供一個Handler介面提供ServeHTTP方法，實現handler介面的函數，可以處理實際request並返回response。
ServeMux和handler函數的串連橋樑就是Handler介面。ServeMux的ServeHTTP方法實現了尋找註冊路由的handler的函數，並調用該handler的ServeHTTP方法。
所以說Handler介面是一個重要樞紐。

簡單梳理下整個請求響應過程，如

HTTP Server流程圖