Go http server (I) 源码阅读

作者: 小小小超子 | 来源:发表于2018-06-02 15:34 被阅读22次

这个系列会写三到四篇文章，第一篇是 go sdk 里 net/http/server.go 的阅读笔记，之后会写一下如何利用 server.go 的接口自定义一个简易通用的 HTTP server 框架。

example

先从一个简单的例子开始吧：

package main

import (
    "net/http"
    "fmt"
    "log"
)

//开启web服务
func test() {
    http.HandleFunc("/", sayHello)
    err := http.ListenAndServe(":9090", nil) // 注意这里第二个参数为 nil
    if err != nil {
        log.Fatal("ListenAndServer:", err)
    }
}

func sayHello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello Guest!")
}

func main() {
    test()
}

运行代码，此时浏览器访问localhost:9090就会看到输出 “Hello Guest!”，其实访问localhost:9090/+任意字符串，都能得到结果。这段代码先用http.HandleFunc注册了一个处理函数，然后调用http.ListenAndServe监听端口，当有请求到来时，会根据访问路径找到并执行对应的处理函数。

我们通常还能看到另一种写法：

package main

import (
    "net/http"
    "fmt"
    "log"
)

//开启web服务
func test() {
  http.Handle("/", &handler{})
    err := http.ListenAndServe(":9090", nil) //
    if err != nil {
        log.Fatal("ListenAndServer:", err)
    }
}

func sayHello(w http.ResponseWriter, r *http.Request) {...}

func main() {
    test()
}

type handler struct{}

func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    sayHello(w, r)
}

这段代码效果一样。区别就是http.HandleFunc和http.Handle需要的第二个参数，前者要一个func (w http.ResponseWriter, r *http.Request)函数，后者要一个实现了该函数的结构体。

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    mux.Handle(pattern, HandlerFunc(handler))
}

func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

可以看到，两个函数都会调用mux.handle

func (mux *ServeMux) Handle(pattern string, handler Handler)

第二个参数是Handler，是一个接口:

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

现在回到上面的HandleFunc,注意这个：HandlerFunc(handler),这里很容易让人误以为HandlerFunc是一个函数并且包装了传入的handler，再返回一个Handler类型。而实际上这里是类型转换，来看HandlerFunc的定义：

type HandlerFunc func(ResponseWriter, *Request)

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

虽然HandlerFunc的类型是一个函数，但它是一种类型，因为是以type来定义而不是func，并且实现了ServeHTTP(w ResponseWriter, r *Request)，在这个函数里，它又调用了自身。这个细节是十分重要的，因为这一步关乎到当路由规则匹配时，相应的响应方法是否会被调用的问题！这里的类型转换用法使一个函数自身实现了一个接口，就不用每次都要先写一个本身无用结构体，再用结构体实现接口。请仔细体会这种技巧！

。。。有点扯偏了，这里记住 Handler 这个接口是 go 语言 HTTP 服务最最最重要的接口，官方库和第三方库都按照这个接口来扩展。

Server

来看一下 Server 这个结构体吧, 这里我只列出了几个核心的域：

type Server struct {
    Addr      string      // TCP address to listen on, ":http" if empty
    Handler   Handler     // handler to invoke, http.DefaultServeMux if nil
    TLSConfig *tls.Config // optional TLS config, used by ServeTLS and ListenAndServeTLS

    listeners  map[net.Listener]struct{}
    onShutdown []func()
}

handler

这里主要关注 Handler，这个 Handler 就是刚刚的那个接口，可以在创建 Server 时传入，也可以在调用 Server.ListenAndServe 时传入：

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

这个 handler 是在建立连接后收到客户端请求时用到：

func (c *conn) serve(ctx context.Context) { // conn 指当前连接
    ...
    for {
        w, err := c.readRequest(ctx)
        ...
        serverHandler{c.server}.ServeHTTP(w, w.req)
        ...
    }
}

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

从 serverHandler 的 ServeHTTP 函数可以看到，当 server.handler==nil 时，使用内部全局变量，也就是前面提到过的 DefaultServeMux。也就是说，我们在收到请求时通过这个 handler 来执行自己的逻辑代码，所以这个 handler 必须包含路由功能，并且能够执行路由对应的处理函数。同时我们用的第三方 HTTP server 框架(echo、beego…)也是通过自定义 handler 来实现功能扩展。这也是 Handler 这个接口是最最重要的接口的原因。

关于 DefaultServeMux 和自定义的 handler，会在之后详细讨论。接下来回到 Server 本身。

Server.Serve

在主函数中可以调用 http.ListenAndServe 或者 http.Serve 来开始 HTTP 服务，原理都一样：

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

仔细看下 srv.Serve 的实现：

func (srv *Server) Serve(l net.Listener) error {
    defer l.Close()
    
    var tempDelay time.Duration // how long to sleep on accept failure

    if err := srv.setupHTTP2_Serve(); err != nil {// 如果设置了 http2，就使用 http2 服务，
        return err
    }

    baseCtx := context.Background() // base is always background, per Issue 16220
    ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    for {
        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
        c := srv.newConn(rw)
        c.setState(c.rwc, StateNew) // before Serve can return
        go c.serve(ctx)
    }
}

这里要详细解释一下的就是 Accept 返回的 error 了。有以下几种可能：

Accept 的时候 Server 由于某种原因停止了
收到系统信号产生中断，当然如果返回的是 EINTR 表示可以重新调用
之前断掉的连接在短时间被重用了，此时该连接处于 TIME_WAIT 状态，新连接暂时不可用。可参考这里

对于暂时性的错误，可以稍等一会儿，所以会出现 sleep。如果成功拿到 conn，先标记连接状态，然后创建新 goroutine 开始对连接服务。

conn.serve

func (c *conn) serve(ctx context.Context) {
    c.remoteAddr = c.rwc.RemoteAddr().String()
    ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())
    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)
        }
    }()

    if tlsConn, ok := c.rwc.(*tls.Conn); ok {
        // 处理 https
    }

    // HTTP/1.x from here on.

    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)
        }
        if err != nil {
            // handle error
            return
        }

        // 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) // 这里就是之前提到的，自定义处理的入口
        w.cancelCtx()
        if c.hijacked() {
            return
        }
        w.finishRequest() // 把数据 flush 到网络层，此次请求在应用层结束
        if !w.shouldReuseConnection() {
            if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
                c.closeWriteAndWait() // 发送 TCP FIN ，关闭连接
            }
            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{})
    }
}

这里代码比较复杂，包含了比较完整的 HTTP、HTTPs、HTTP2 协议的实现，建议了解了协议的内容再来看具体实现。代码协议的细节部分代码就不详细谈了，我们需要理解的是创建 listener，从 Accept 拿到连接，等待并读取到 request，用 handler 处理 request 并把结果或错误信息写到 response 的过程。

需要注意的是，我们所讨论的是 go 语言官方库的 HTTP 的实现，这里的发送和接收数据都是指的发给下层传输层和从传输层接收，也就是调用 socket 接口，一定要分清楚各个层次。

Go http server (I) 源码阅读

example

Server

handler

Server.Serve

conn.serve

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Go语言