Go語言中HTTP Server:

HTTP server，顧名思義，支持http協(xié)議的服務(wù)器，HTTP是一個簡單的請求-響應(yīng)協(xié)議，通常運行在TCP之上。通過客戶端發(fā)送請求給服務(wù)器得到對應(yīng)的響應(yīng)。

HTTP服務(wù)簡單實現(xiàn)

package main

import (
    "fmt"
    "net/http"
)

//③處理請求，返回結(jié)果
func Hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "hello world")
}

func main() {
    //①路由注冊
    http.HandleFunc("/", Hello) 
    //②服務(wù)監(jiān)聽
    http.ListenAndServe(":8080", nil)
}

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

源碼分析

①路由注冊

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 = &defaultServeMux

var defaultServeMux ServeMux

type 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是實現(xiàn)Handler接口的類型）。通過實現(xiàn)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是一個函數(shù)類型，并實現(xiàn)了Handler接口。當通過調(diào)用HandleFunc()，把Hello強轉(zhuǎn)為HandlerFunc類型時，就意味著 Hello函數(shù)也實現(xiàn)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
    }
   //這里是綁定靜態(tài)目錄，不作為本片重點。
    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}
    }
}

上面的流程就完成了路由注冊。

②服務(wù)監(jiān)聽

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

//初始化監(jiān)聽地址Addr，同時調(diào)用Listen方法設(shè)置監(jiān)聽。
//***將監(jiān)聽的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的設(shè)計，保證了go的高并發(fā)。

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())
    //開啟循環(huán)進行監(jiān)聽
    for {
       //通過Listener的Accept方法用來獲取連接數(shù)據(jù)
        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
        //通過獲得的連接數(shù)據(jù)，創(chuàng)建newConn連接對象
        c := srv.newConn(rw)
                c.setState(c.rwc, StateNew) // before Serve can return
       //開啟goroutine發(fā)送連接請求
        go c.serve(ctx)
    }
}

serve()為核心,讀取對應(yīng)的連接數(shù)據(jù)進行分配

func (c *conn) serve(ctx context.Context) {
    c.remoteAddr = c.rwc.RemoteAddr().String()
        //連接關(guān)閉相關(guān)的處理
    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)
        }

                .................
        //處理網(wǎng)絡(luò)數(shù)據(jù)的狀態(tài)
        // 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()
        }

        //調(diào)用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{})
    }
}

③處理請求，返回結(jié)果

serverHandler 主要初始化路由多路復(fù)用器。如果server對象沒有指定Handler，則使用默認的DefaultServeMux作為路由多路復(fù)用器。并調(diào)用初始化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函數(shù)
    h, _ := mux.Handler(r)
    //調(diào)用handler函數(shù)的ServeHTTP方法
    //即Hello函數(shù)，然后把數(shù)據(jù)寫到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函數(shù)并返回。
        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
    }
        //靜態(tài)文件匹配
    return len(path) >= n && path[0:n] == pattern
}

將數(shù)據(jù)寫給客戶端

//主要代碼，通過層層封裝才走到這一步

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)當請求結(jié)束后，就開始執(zhí)行連接斷開的相關(guān)邏輯。

總結(jié)

Go語言通過一個ServeMux實現(xiàn)了的路由多路復(fù)用器來管理路由。同時提供一個Handler接口提供ServeHTTP方法，實現(xiàn)handler接口的函數(shù)，可以處理實際request并返回response。

ServeMux和handler函數(shù)的連接橋梁就是Handler接口。ServeMux的ServeHTTP方法實現(xiàn)了尋找注冊路由的handler的函數(shù)，并調(diào)用該handler的ServeHTTP方法。

所以說Handler接口是一個重要樞紐。

簡單梳理下整個請求響應(yīng)過程，如下圖