这个系列会写三到四篇文章，第一篇是 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 接口，一定要分清楚各个层次。