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程同时使用。出于效率考虑，应该一次创建、尽可能重用。

以上若有误导的地方，请前辈们务必指出！