Golang HTTP程式設計及原始碼解析

1、網路基礎

基本TCP客戶-伺服器程式Socket程式設計流程如如下圖所示。

TCP伺服器繫結到特定埠並阻塞監聽使用者端端連線，

TCP使用者端則通過IP+埠向伺服器發起請求，客戶-伺服器建立連線之後就能開始進行資料傳輸。

Golang的TCP程式設計也是基於上述流程的。

2、Golang HTTP程式設計

2.1 程式碼範例

func timeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "%v", time.Now().Format(time.RFC3339))
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "%v", "hello world.")
}

func main() {
	// 1. 新建路由解碼器
	h := http.NewServeMux()
	// 2. 路由註冊
	h.HandleFunc("/hello", helloHandler)
	h.HandleFunc("/time", timeHandler)
	// 3. 服務啟動 阻塞監聽
	http.ListenAndServe(":8000", h)
}

執行上述程式，在瀏覽器位址列分別輸入 http://localhost:8000/hello http://localhost:8000/time 結果分別如下圖所示。

2.2 原始碼分析

分析從路由註冊到響應使用者請求的流程。

2.2.1 新建解碼器 h := http.NewServeMux()

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
}
// NewServeMux allocates and returns a new ServeMux.
func NewServeMux() *ServeMux { return new(ServeMux) }

Handler是interface，定義如下

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

ServeMux實現了Handler介面。

2.2.2 路由註冊 h.HandleFunc("/hello", helloHandler)

// HandleFunc registers the handler function for the given pattern.
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    ...
    mux.Handle(pattern, HandlerFunc(handler))
}

func (mux *ServeMux) Handle(pattern string, handler Handler) {
    ...
    e := muxEntry{h: handler, pattern: pattern}
    mux.m[pattern] = e
    if pattern[len(pattern)-1] == '/' {
        mux.es = appendSorted(mux.es, e)
    }
    ...
}

timeHandler和helloHandler函數被強制轉換為type HandlerFunc func(ResponseWriter, *Request)型別，且實現了Handler介面。

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
	f(w, r)
}

mux.m建立了路由到處理常式timeHandler和helloHandler的對映。

2.2.3 服務啟動阻塞監聽 http.ListenAndServe(":8000", h)

包裝Server結構體，HTTP使用TCP協定。

func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}
func (srv *Server) ListenAndServe() error {
	...
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		return err
	}
	return srv.Serve(ln)
}

net.Listen封裝了Socket程式設計的socket，bind，listen的呼叫，極大的方便了使用者。

阻塞監聽請求，新建goroutine處理每個新請求。

func (srv *Server) Serve(l net.Listener) error {
    ...
    for {
        rw, err := l.Accept()
        ...
        c := srv.newConn(rw)
        c.setState(c.rwc, StateNew, runHooks) // before Serve can return
        go c.serve(connCtx)
    }
}
// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
    ...
    serverHandler{c.server}.ServeHTTP(w, w.req)
    ...
}
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
    handler := sh.srv.Handler
    ...
    handler.ServeHTTP(rw, req)
}

通過前面的流程推導可知，handler是http.ListenAndServe的第二個引數ServeMux

// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
	...
	h, _ := mux.Handler(r) // 通過路由獲取處理常式
	h.ServeHTTP(w, r)
}

mux.Handler使用mux.m這個map通過請求URL找到對應處理常式的。

h的實際型別為HandlerFunc，根據2.2.2會呼叫到具體函數timeHandler或者helloHandler。

3. 總結

golang對socket程式設計進行了封裝，給HTTP程式設計帶來了極大的便利。

但是不支援以下特性

1. 路由分組 對路由進行分組，可以方便分組鑑權

2. 動態路由 如動態路由/user/:username/post/:postid不支援