Go語言HTTP Server源碼分析

作者：佚名 2017-04-10 20:21:39

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

Go語言中HTTP Server:

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

HTTP服務簡單實現

package main  
import ( 
    "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) 
}

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

源碼分析

①路由注冊

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是實現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接口是一個重要樞紐。

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

責任編輯：未麗燕來源：碼農網

Go語言源碼分析 Handler