Go語言備忘錄（3）：net/http包的使用模式和源碼解析

時間 2019-12-13

原文原文鏈接

本文是晚輩對net/http包的一點淺顯的理解，文中若有錯誤的地方請前輩們指出，以避免誤導！html

轉摘本文也請註明出處：Go語言備忘錄（3）：net/http包的使用模式和源碼解析，多謝！ 緩存

目錄：
安全

1、http包的3個關鍵類型：
Handler接口：全部請求的處理器、路由ServeMux都知足該接口；

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

ServeMux結構體：HTTP請求的多路轉接器（路由），它負責將每個接收到的請求的URL與一個註冊模式的列表進行匹配，並調用和URL最匹配的模式的處理器。它內部用一個map來保存全部處理器Handler

http包有一個包級別變量DefaultServeMux，表示默認路由：var DefaultServeMux = NewServeMux()，使用包級別的http.Handle()、http.HandleFunc()方法註冊處理器時都是註冊到該路由中；
ServeMux結構體有ServeHTTP()方法（知足Handler接口），主要用於間接調用它所保存的處理器的ServeHTTP()方法

http.HandlerFunc函數類型：它知足Handler接口

type HandlerFunc func(ResponseWriter, *Request)
//實現Handler接口的ServeHTTP方法
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r) //調用自身
}

2、HTTP服務器的使用模式：
處理函數：只要函數的簽名爲 func(w http.ResponseWriter, r *http.Request) ，都可做爲處理函數，即它能夠被轉換爲http.HandlerFunc函數類型；

模式一：使用默認的路由來註冊處理函數：

 
        var addr = flag.String("addr", ":8080", "http server address")
//1.不帶參數處理函數
func serveHome(w http.ResponseWriter, r *http.Request) {
   if r.URL.Path != "/" {
       http.NotFound(w, r)
       return
   }
   http.ServeFile(w, r, "home.html")
}
//2.帶參數處理函數，閉包函數隱式轉換爲http.HandlerFunc函數類型
func myHandler(s string) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/" {
            http.NotFound(w, r)
            return
        }
        http.ServeFile(w, r, s) //使用參數s
    }
}
func main() {
   flag.Parse()
    
   //向默認路由註冊處理器函數
   http.HandleFunc("/", serveHome) //或http.Handle("/", http.HandlerFunc(serveHome))
   http.Handle("/file",myHandler("somefile"))
    
   err := http.ListenAndServe(*addr, nil) //啓動監聽，第二個參數nil表示使用默認路由DefaultServeMux中註冊的處理器
   if err != nil {
      log.Fatalln("ListenAndServe: ", err)
   }
} 
       

模式二：使用自定義的路由來註冊處理函數：

 
     func main() {
  mux := http.NewServeMux() //新建一個自定義的路由
  mux.Handle("/file",myHandler("somefile"))
  mux.HandleFunc("/", serveHome) 
    
  err := http.ListenAndServe(*addr,mux) //啓動監聽
   if err != nil {
      log.Fatalln("ListenAndServe: ", err)
   }
} 
    

模式三：直接自定義一個Server實例：該模式能夠很方便的管理服務端的行爲

 mux := http.NewServeMux()
 mux.Handle("/file",myHandler("somefile"))
 mux.HandleFunc("/", serveHome) 

 s := &http.Server{
    Addr: ":8080",
    Handler: mux, //指定路由或處理器，不指定時爲nil，表示使用默認的路由DefaultServeMux
    ReadTimeout: 10 * time.Second,
    WriteTimeout: 10 * time.Second,
    MaxHeaderBytes: 1 << 20,
    ConnState: //指定鏈接conn的狀態改變時的處理函數
        //....
 }
 log.Fatal(s.ListenAndServe())

接下來，咱們就跟蹤源碼來仔細的分析下整個執行過程。服務器

3、HTTP服務器的執行過程：
1.使用http.ListenAndServe()方法啓動服務，它根據給定參數構造Server類型，而後調用server.ListenAndServe()

func ListenAndServe(addr string, handler Handler) error {
    server := &Server{Addr: addr, Handler: handler}
    return server.ListenAndServe()
}

　　
2.而server.ListenAndServe()方法內部調用net.Listen("tcp", addr)，該方法內部又調用net.ListenTCP()建立並返回一個監聽器net.Listener，以下的ln；閉包

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

3.而後把監聽器 ln 斷言轉換爲 TCPListener 類型，並根據它構造一個 tcpKeepAliveListener 對象並傳遞給server.Serve()方法；

由於TCPListener實現了Listener接口，因此tcpKeepAliveListener也實現了Listener接口，而且它重寫了Accept()方法，目的是爲了調用SetKeepAlive(true)，讓操做系統爲收到的每個鏈接啓動發送keepalive消息(心跳，爲了保持鏈接不斷開)。

type tcpKeepAliveListener struct {
    *net.TCPListener
}
func (ln tcpKeepAliveListener) Accept() (c net.Conn, err error) {
    tc, err := ln.AcceptTCP()
    if err != nil {
        return
    }
    tc.SetKeepAlive(true) //發送心跳
    tc.SetKeepAlivePeriod(3 * time.Minute) //發送週期
    return tc, nil
}

4.server.Serve()方法調用tcpKeepAliveListener 對象的 Accept() 方法返回一個鏈接conn（該鏈接啓動了心跳），併爲每個conn建立一個新的go程執行conn.server()方法：具體見代碼中我加的註釋說明

func (srv *Server) Serve(l net.Listener) error {
    defer l.Close()
    if fn := testHookServerServe; fn != nil {
        fn(srv, l)
    }
    var tempDelay time.Duration //重試間隔

    if err := srv.setupHTTP2_Serve(); err != nil {
        return err
    }

    srv.trackListener(l, true) //緩存該監聽器
    defer srv.trackListener(l, false) //從緩存中刪除當前監聽器

    baseCtx := context.Background() 
    ctx := context.WithValue(baseCtx, ServerContextKey, srv) //新建一個context用來管理每一個鏈接conn的Go程
    for {
        rw, e := l.Accept() //調用tcpKeepAliveListener對象的 Accept() 方法
        if e != nil {
            select {
            case <-srv.getDoneChan():
                return ErrServerClosed //退出Serve方法，並執行延遲調用（從緩存中刪除當前監聽器）
            default:
            }
            //若是發生了net.Error錯誤，則隔一段時間就重試一次，間隔時間每次翻倍，最大爲1秒
            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
        c := srv.newConn(rw) //該方法根據net.Conn、srv構造了一個新的http.conn類型
        c.setState(c.rwc, StateNew) //緩存該鏈接的狀態，若是方法：Server.ConnState(net.Conn, ConnState)不爲nil，就根據當前鏈接的狀態執行它
        go c.serve(ctx)
    }
}

5.而conn.server( )方法會讀取請求，而後根據conn內保存的server來構造一個serverHandler類型，並調用它的ServeHTTP()方法：serverHandler{c.server}.ServeHTTP(w, w.req)，該方法的源碼以下：

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

6.如上源碼能夠看到，當 handler == nil 時使用默認的DefaultServeMux路由，不然使用在第1步中爲Serve指定了的Handler；而後調用該Handler的ServeHTTP方法（該Handler通常被設置爲路由ServeMux類型）；tcp

7.而路由ServeMux的ServeHTTP方法則會根據當前請求提供的信息來查找最匹配的Handler（這裏爲）：

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) //規範化請求的路徑格式，查找最匹配的Handler
    h.ServeHTTP(w, r)
}

8.以上查找到的Handler接口值h就是咱們事先註冊到路由中與請求匹配的Handler；而h的動態類型是HandlerFunc類型（它也知足Handler接口）；

因此，以上 h.ServeHTTP(w, r) 實際上調用的是接口值h中持有的動態值（也就是咱們定義的處理函數）

type HandlerFunc func(ResponseWriter, *Request)
//實現Handler接口的ServeHTTP方法
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r) //調用自身
}

至此，整個調用過程講解完畢，至於業務層的處理邏輯，則由各個處理函數實現

4、重定向：
http包自帶了幾個建立經常使用處理器的函數：FileServer，NotFoundHandler、RedirectHandler、StripPrefix、TimeoutHandler。
而 RedirectHandler函數就是用來重定向的：它返回一個請求處理器，該處理器會對每一個請求都使用狀態碼code重定向到網址url

func main() {
  mux := http.NewServeMux()
  mux.Handle("/to",http.RedirectHandler("http://example.org", 307))
  err := http.ListenAndServe(*addr,mux) //啓動監聽
   if err != nil {
      log.Fatalln("ListenAndServe: ", err)
   }
}

好了，本文就暫時講關於http包關於HTTP服務端方面的東西，至於客戶端方面的就簡單引用一下官方文檔說明吧，畢竟客戶端不多用Go實現。

5、客戶端的實現：

Get、Head、Post和PostForm函數發出HTTP/ HTTPS請求。函數

resp, err := http.Get("http://example.com/")
...
resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
...
resp, err := http.PostForm("http://example.com/form",
	url.Values{"key": {"Value"}, "id": {"123"}})

程序在使用完回覆後必須關閉回覆的主體。url

resp, err := http.Get("http://example.com/")
if err != nil {
	// handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
// ...

要管理HTTP客戶端的頭域、重定向策略和其餘設置，建立一個Client：spa

client := &http.Client{
	CheckRedirect: redirectPolicyFunc,
}
resp, err := client.Get("http://example.com")
// ...
req, err := http.NewRequest("GET", "http://example.com", nil)
// ...
req.Header.Add("If-None-Match", `W/"wyzzy"`)
resp, err := client.Do(req)
// ...

要管理代理、TLS配置、keep-alive、壓縮和其餘設置，建立一個Transport：操作系統

tr := &http.Transport{
	TLSClientConfig:    &tls.Config{RootCAs: pool},
	DisableCompression: true,
}
client := &http.Client{Transport: tr}
resp, err := client.Get("https://example.com")

Client和Transport類型均可以安全的被多個go程同時使用。出於效率考慮，應該一次創建、儘可能重用。

以上若有誤導的地方，請前輩們務必指出！