Go HTTP

星期一, 11月 9, 2020 | 15分钟阅读 | 更新于 星期日, 11月 15, 2020

@

超文本传输协议(Hypertext Transfer Protocol、HTTP协议)是今天使用最广泛的应用层协议,1989年由Tim Berners-Lee在CERN起草的协议已经成为了互联网的数据传输的核心。在过去几年的时间里,HTTP/2和HTTP/3也对现有的协议进行了更新,提供更加安全和快速的传输功能。多数的编程语言都会在标准库中实现HTTP/1.1和HTTP/2.0已满足工程师的日常开发需求,Go语言的网络库也实现了这两个大版本的HTTP协议。

一、设计原理

HTTP协议是应用层协议,在通常情况下我们都会使用TCP作为底层的传输层协议传输数据包,但是HTTP/3在UDP协议上实现了新的传输层协议QUIC来传输数据,这也意味着HTTP既可以跑在TCP上,也可以跑在UDP上。Go语言标准库通过net/http包提供HTTP的客户端和服务端实现。

请求和响应 HTTP协议中最常见的概念是HTTP请求与响应,我们可以将它们理解成客户端和服务端之间传递的消息,客户端向服务端发送HTTP 请求,服务端收到HTTP请求后会做出计算后以HTTP响应的形式发送给客户端。 与其他的二进制协议不同,作为文本传输协议,HTTP协议的协议头都是文本数据,HTTP请求头的首行会包含请求的方法、路径和协议版本,接下来是多个HTTP协议头以及携带的负载。

GET / HTTP/1.1
User-Agent: Mozilla/4.0 (compatible; MSIE5.01; Windows NT)
Host: draveness.me
Accept-Language: en-us
Accept-Encoding: gzip, deflate
Content-Length: <length>
Connection: Keep-Alive

<html>
    ...
</html>

HTTP响应也有着比较类似的结构,其中也包含响应的协议版本、状态码、响应头以及负载。

消息边界 HTTP协议目前主要还是跑在TCP协议上的,TCP协议是面向连接的、可靠的、基于字节流的传输层通信协议,应用层交给TCP协议的数据并不会以消息为单位向目的主机传输,这些数据在某些情况下会被组合成一个数据段发送给目标的主机。因为TCP协议是基于字节流的,所以基于TCP协议的应用层协议都需要自己划分消息的边界。 在应用层协议中,最常见的两种解决方案就是基于长度或者基于终结符(Delimiter)。HTTP 协议其实同时实现了上述两种方案,在多数情况下HTTP协议都会在协议头中加入Content-Length表示负载的长度,消息的接收者解析到该协议头之后就可以确定当前 HTTP请求/响应结束的位置,分离不同的HTTP消息,下面就是一个使用Content-Length划分消息边界的例子:

HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
Content-Length: 138
...
Connection: close

<html>
  <head>
    <title>An Example Page</title>
  </head>
  <body>
    <p>Hello World, this is a very simple HTML document.</p>
  </body>
</html>

不过HTTP协议除了使用基于长度的方式实现边界,也会使用基于终结符的策略,当HTTP使用块传输(Chunked Transfer)机制时,HTTP头中就不再包含Content-Length了,它会使用负载大小为0的HTTP消息作为终结符表示消息的边界。

层级结构 Go语言的net/http中同时包好了HTTP客户端和服务端的实现,为了支持更好的扩展性,它引入了net/http.RoundTripper和 net/http.Handler两个接口。net/http.RoundTripper是用来表示执行HTTP请求的接口,调用方将请求作为参数可以获取请求对应的响应,而net/http.Handler主要用于HTTP服务器响应客户端的请求:

type RoundTripper interface {
    RoundTrip(*Request) (*Response, error)
}

HTTP请求的接收方可以实现net/http.Handler接口,其中实现了处理HTTP请求的逻辑,处理的过程中会调用net/http.ResponseWriter接口的方法构造HTTP响应,它提供的三个接口Header、Write和WriteHeader分别会获取HTTP响应、将数据写入负载以及写入响应头:

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

type ResponseWriter interface {
	Header() Header
	Write([]byte) (int, error)
	WriteHeader(statusCode int)
}

客户端和服务端面对的都是双向的HTTP请求与响应,客户端构建请求并等待响应,服务端处理请求并返回响应。HTTP请求和响应在标准库中不止有一种实现,它们都包含了层级结构。每个net/http.RoundTripper接口的实现都包含了一种向远程发出请求的过程;标准库中也提供了多种net/http.Handler的实现为客户端的HTTP请求提供不同的服务。

二、客户端

客户端可以直接通过net/http.Get函数使用默认的客户端net/http.DefaultClient发起HTTP请求,也可以自己构建新的net/http.Client实现自定义的HTTP事务,在多数情况下使用默认的客户端都能满足我们的需求,不过需要注意的是使用默认客户端发出的请求没有超时时间,所以在某些场景下会一直等待下去;除了自定义HTTP事务之外,我们还可以实现自定义的net/http.CookieJar接口来管理和使用HTTP请求中的Cookie,事务和Cookie是我们在HTTP客户端包为我们提供的两个最重要模块。当我们调用net/http.Client.Get方法发出HTTP时,会按照如下的步骤执行:

  • 调用net/http.NewRequest根据方法名、URL和请求体构建请求;
  • 调用net/http.Transport.RoundTrip开启HTTP事务、获取连接并发送请求;
  • 在HTTP持久连接的 net/http.persistConn.writeLoop方法中等待响应;

HTTP的客户端中包含几个比较重要的结构体,它们分别是net/http.Client、net/http.Transport和net/http.persistConn:

  • net/http.Client是HTTP客户端,它的默认值是使用net/http.DefaultTransport的HTTP客户端;
  • net/http.Transport是net/http.RoundTripper接口的实现,它的主要作用就是支持 HTTP/HTTPS 请求和HTTP代理;
  • net/http.persistConn封装了一个TCP的持久连接,是我们与远程交换消息的句柄(Handle); 客户端net/http.Client是级别较高的抽象,它提供了HTTP的一些细节,包括Cookies和重定向;而net/http.Transport结构体会处理HTTP/HTTPS协议的底层实现细节,其中会包含连接重用、构建请求以及发送请求等功能。

构建请求 net/http.Request结构体表示HTTP服务接收到的请求或者HTTP客户端发出的请求,其中包含HTTP请求的方法、URL、协议版本、协议头以及请求体等字段,除了这些字段之外,它还会持有一个指向HTTP响应的引用:

type Request struct {
	Method string
	URL *url.URL

	Proto      string // "HTTP/1.0"
	ProtoMajor int    // 1
	ProtoMinor int    // 0

	Header Header
	Body io.ReadCloser

	...
	Response *Response
}

net/http.NewRequest是标准库提供的用于创建请求的方法,这个方法会对HTTP请求的字段进行校验并根据输入的参数拼装成新的请求结构体。

func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
	if method == "" {
		method = "GET"
	}
	if !validMethod(method) {
		return nil, fmt.Errorf("net/http: invalid method %q", method)
	}
	u, err := urlpkg.Parse(url)
	if err != nil {
		return nil, err
	}
	rc, ok := body.(io.ReadCloser)
	if !ok && body != nil {
		rc = ioutil.NopCloser(body)
	}
	u.Host = removeEmptyPort(u.Host)
	req := &Request{
		ctx:        ctx,
		Method:     method,
		URL:        u,
		Proto:      "HTTP/1.1",
		ProtoMajor: 1,
		ProtoMinor: 1,
		Header:     make(Header),
		Body:       rc,
		Host:       u.Host,
	}
	if body != nil {
		...
	}
	return req, nil
}

请求拼装的过程比较简单,它会检查对输入的方法、URL以及负载,对它们进行校验并初始化了新的net/http.Request结构体,处理负载的过程稍微有一些复杂,我们会根据负载的类型不同,使用不同的方法将它们包装成io.ReadCloser类型。

开启事务 当我们使用标准库构建了HTTP请求之后,就会开启HTTP事务发送HTTP请求并等待远程的响应,经过下面一连串的函数调用,我们最终来到了标准库实现底层HTTP协议的结构体 — net/http.Transport:

  1. net/http.Client.Do
  2. net/http.Client.do
  3. net/http.Client.send
  4. net/http.send
  5. net/http.Transport.RoundTrip net/http.Transport实现了net/http.RoundTripper接口,也是整个请求过程中最重要并且最复杂的结构体,该结构体会在net/http.Transport.roundTrip方法中发送HTTP请求并等待响应,我们可以将该函数的执行过程分成两个部分:
  • 根据 URL 的协议查找并执行自定义的net/http.RoundTripper实现;
  • 从连接池中获取或者初始化新的持久连接并调用连接的net/http.persistConn.roundTrip方法发出请求; 可以在标准库的net/http.Transport中调用net/http.Transport.RegisterProtocol方法为不同的协议注册net/http.RoundTripper的实现,在下面的这段代码中就会根据URL中的协议选择对应的实现来替代默认的逻辑:
func (t *Transport) roundTrip(req *Request) (*Response, error) {
	ctx := req.Context()
	scheme := req.URL.Scheme

	if altRT := t.alternateRoundTripper(req); altRT != nil {
		if resp, err := altRT.RoundTrip(req); err != ErrSkipAltProtocol {
			return resp, err
		}
	}
	...
}

在默认情况下我们都会使用net/http.persistConn持久连接处理HTTP请求,该方法会先获取用于发送请求的连接,随后调用net/http.persistConn.roundTrip方法:

func (t *Transport) roundTrip(req *Request) (*Response, error) {
	...
	for {
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		default:
		}

		treq := &transportRequest{Request: req, trace: trace}
		cm, err := t.connectMethodForRequest(treq)
		if err != nil {
			return nil, err
		}

		pconn, err := t.getConn(treq, cm)
		if err != nil {
			return nil, err
		}

		resp, err := pconn.roundTrip(treq)
		if err == nil {
			return resp, nil
		}
	}
}

net/http.Transport.getConn是获取连接的方法,该方法会通过两种方法获取用于发送请求的连接:

func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {
	req := treq.Request
	ctx := req.Context()

	w := &wantConn{
		cm:         cm,
		key:        cm.key(),
		ctx:        ctx,
		ready:      make(chan struct{}, 1),
	}

	if delivered := t.queueForIdleConn(w); delivered {
		return w.pc, nil
	}

	t.queueForDial(w)
	select {
	case <-w.ready:
		...
		return w.pc, w.err
	...
	}
}
  1. 调用net/http.Transport.queueForIdleConn在队列中等待闲置的连接;
  2. 调用net/http.Transport.queueForDial在队列中等待建立新的连接; 连接是一种相对比较昂贵的资源,如果在每次发出HTTP请求之前都建立新的连接,可能会消耗比较多的时间,带来较大的额外开销,通过连接池对资源进行分配和复用可以有效地提高HTTP请求的整体性能,多数的网络库客户端都会采取类似的策略来复用资源。

当我们调用net/http.Transport.queueForDial方法尝试与远程建立连接时,标准库会在内部启动新的Goroutine执行net/http.Transport.dialConnFor用于建连,从最终调用的net/http.Transport.dialConn方法中我们能找到TCP连接和net库的身影:

func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *persistConn, err error) {
	pconn = &persistConn{
		t:             t,
		cacheKey:      cm.key(),
		reqch:         make(chan requestAndChan, 1),
		writech:       make(chan writeRequest, 1),
		closech:       make(chan struct{}),
		writeErrCh:    make(chan error, 1),
		writeLoopDone: make(chan struct{}),
	}

	conn, err := t.dial(ctx, "tcp", cm.addr())
	if err != nil {
		return nil, err
	}
	pconn.conn = conn

	pconn.br = bufio.NewReaderSize(pconn, t.readBufferSize())
	pconn.bw = bufio.NewWriterSize(persistConnWriter{pconn}, t.writeBufferSize())

	go pconn.readLoop()
	go pconn.writeLoop()
	return pconn, nil
}

在创建新的TCP连接后,我们还会在后台为当前的连接创建两个Goroutine,分别从TCP连接中读取数据或者向TCP连接写入数据,从建立连接的过程我们就可以发现,如果我们为每一个HTTP请求都创建新的连接并启动Goroutine处理读写数据,会占用很多的资源。

等待请求 持久的TCP连接会实现net/http.persistConn.roundTrip方法处理写入HTTP请求并在select语句中等待响应的返回:

func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err error) {
	writeErrCh := make(chan error, 1)
	pc.writech <- writeRequest{req, writeErrCh, continueCh}

	resc := make(chan responseAndError)
	pc.reqch <- requestAndChan{
		req:        req.Request,
		ch:         resc,
	}

	for {
		select {
		case re := <-resc:
			if re.err != nil {
				return nil, pc.mapRoundTripError(req, startBytesWritten, re.err)
			}
			return re.res, nil
		...
		}
	}
}

每个HTTP请求都是由另一个Goroutine中的net/http.persistConn.writeLoop循环写入的,这两个Goroutine独立执行并通过Channel进行通信。net/http.Request.write方法会根据 net/http.Request结构体中的字段按照HTTP协议组成TCP数据段:

func (pc *persistConn) writeLoop() {
	defer close(pc.writeLoopDone)
	for {
		select {
		case wr := <-pc.writech:
			startBytesWritten := pc.nwrite
			wr.req.Request.write(pc.bw, pc.isProxy, wr.req.extra, pc.waitForContinue(wr.continueCh))
			...
		case <-pc.closech:
			return
		}
	}
}

当我们调用net/http.Request.write方法向请求中写入数据时,实际上就直接写入了net/http.persistConnWriter中的TCP连接中,TCP协议栈会负责将HTTP请求中的内容发送到目标服务器上:

type persistConnWriter struct {
	pc *persistConn
}

func (w persistConnWriter) Write(p []byte) (n int, err error) {
	n, err = w.pc.conn.Write(p)
	w.pc.nwrite += int64(n)
	return
}

持久连接中的另一个读循环net/http.persistConn.readLoop会负责从TCP连接中读取数据并将数据发送会HTTP请求的调用方,真正负责解析HTTP协议的还是net/http.ReadResponse方法:

func ReadResponse(r *bufio.Reader, req *Request) (*Response, error) {
	tp := textproto.NewReader(r)
	resp := &Response{
		Request: req,
	}

	line, _ := tp.ReadLine()
	if i := strings.IndexByte(line, ' '); i == -1 {
		return nil, badStringError("malformed HTTP response", line)
	} else {
		resp.Proto = line[:i]
		resp.Status = strings.TrimLeft(line[i+1:], " ")
	}

	statusCode := resp.Status
	if i := strings.IndexByte(resp.Status, ' '); i != -1 {
		statusCode = resp.Status[:i]
	}
	resp.StatusCode, err = strconv.Atoi(statusCode)

	resp.ProtoMajor, resp.ProtoMinor, _ = ParseHTTPVersion(resp.Proto)

	mimeHeader, _ := tp.ReadMIMEHeader()
	resp.Header = Header(mimeHeader)

	readTransfer(resp, r)
	return resp, nil
}

我们在上述方法中可以看到HTTP响应结构的大致框架,其中包含状态码、协议版本、请求头等内容,响应体还是在读取循环net/http.persistConn.readLoop中根据HTTP协议头进行解析的。

三、服务器

Go语言标准库net/http包提供了非常易用的接口,如下所示,我们可以利用标准库提供的功能快速搭建新的HTTP服务:

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

上述的main函数只调用了两个标准库提供的函数,它们分别是用于注册处理器的net/http.HandleFunc函数和用于监听和处理器请求的net/http.ListenAndServe,多数的服务器框架都会包含这两类接口,分别负责注册处理器和处理外部请求,这一种非常常见的模式,我们在这里也会按照这两个维度介绍标准库如何支持HTTP服务器的实现。

注册处理器 HTTP服务是由一组实现了net/http.Handler接口的处理器组成的,处理HTTP请求时会根据请求的路由选择合适的处理器。 当我们直接调用net/http.HandleFunc注册处理器时,标准库会使用默认的HTTP服务器net/http.DefaultServeMux处理请求,该方法会直接调用net/http.ServeMux.HandleFunc:

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

上述方法会将处理器转换成net/http.Handler接口类型调用net/http.ServeMux.Handle注册处理器:

func (mux *ServeMux) Handle(pattern string, handler Handler) {
	if _, exist := mux.m[pattern]; exist {
		panic("http: multiple registrations for " + pattern)
	}

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

	if pattern[0] != '/' {
		mux.hosts = true
	}
}

路由和对应的处理器会被组成net/http.DefaultServeMux会持有一个net/http.muxEntry哈希,其中存储了从URL到处理器的映射关系,HTTP服务器在处理请求时就会使用该哈希查找处理器。

处理请求 标准库提供的net/http.ListenAndServe函数可以用来监听 TCP 连接并处理请求,该函数会使用传入的监听地址和处理器初始化一个HTTP服务器net/http.Server,调用该服务器的net/http.Server.ListenAndServe方法:

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

net/http.Server.ListenAndServe方法会使用网络库提供的net.Listen函数监听对应地址上的TCP连接并通过net/http.Server.Serve处理客户端的请求:

func (srv *Server) ListenAndServe() error {
	if addr == "" {
		addr = ":http"
	}
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		return err
	}
	return srv.Serve(ln)
}

net/http.Server.Serve会在循环中监听外部的TCP连接并为每个连接调用net/http.Server.newConn创建新的结构体 net/http.conn,它是HTTP连接的服务端表示:

func (srv *Server) Serve(l net.Listener) error {
	l = &onceCloseListener{Listener: l}
	defer l.Close()

	baseCtx := context.Background()
	ctx := context.WithValue(baseCtx, ServerContextKey, srv)
	for {
		rw, err := l.Accept()
		if err != nil {
			select {
			case <-srv.getDoneChan():
				return ErrServerClosed
			default:
			}
			...
			return err
		}
		connCtx := ctx
		c := srv.newConn(rw)
		c.setState(c.rwc, StateNew) // before Serve can return
		go c.serve(connCtx)
	}
}

创建了服务端的连接之后,标准库中的实现会为每个HTTP请求创建单独的Goroutine并在其中调用net/http.Conn.serve方法,如果当前HTTP服务接收到了海量的请求,会在内部创建大量的Goroutine,这可能会使整个服务质量明显降低无法处理请求。

func (c *conn) serve(ctx context.Context) {
	c.remoteAddr = c.rwc.RemoteAddr().String()

	ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())
	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, _ := c.readRequest(ctx)
		serverHandler{c.server}.ServeHTTP(w, w.req)
		w.finishRequest()
		...
	}
}

上述代码片段是我们简化后的连接处理过程,其中包含读取HTTP请求、调用Handler处理HTTP请求以及调用完成该请求。读取HTTP请求会调用net/http.Conn.readRequest方法,该方法会从连接中获取HTTP请求并构建一个实现了net/http.ResponseWriter接口的变量net/http.response,向该结构体写入的数据都会被转发到它持有的缓冲区中:

func (w *response) write(lenData int, dataB []byte, dataS string) (n int, err error) {
	...
	w.written += int64(lenData)
	if w.contentLength != -1 && w.written > w.contentLength {
		return 0, ErrContentLength
	}
	if dataB != nil {
		return w.w.Write(dataB)
	} else {
		return w.w.WriteString(dataS)
	}
}

解析了HTTP请求并初始化net/http.ResponseWriter之后,我们就可以调用net/http.serverHandler.ServeHTTP方法查找处理器来处理HTTP请求了:

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

如果当前的HTTP服务器中不包含任何处理器,我们会使用默认的net/http.DefaultServeMux处理外部的HTTP请求。 net/http.ServeMux是一个HTTP请求的多路复用器,它可以接收外部的HTTP请求、根据请求的URL匹配并调用最合适的处理器:

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
	h, _ := mux.Handler(r)
	h.ServeHTTP(w, r)
}

经过一系列的函数调用,上述过程最终会调用HTTP服务器的net/http.ServerMux.match方法,该方法会遍历前面注册过的路由表并根据特定规则进行匹配:

func (mux *ServeMux) match(path string) (h Handler, pattern string) {
	v, ok := mux.m[path]
	if ok {
		return v.h, v.pattern
	}

	for _, e := range mux.es {
		if strings.HasPrefix(path, e.pattern) {
			return e.h, e.pattern
		}
	}
	return nil, ""
}

如果请求的路径和路由中的表项匹配成功,我们会调用表项中对应的处理器,处理器中包含的业务逻辑会通过net/http.ResponseWriter构建HTTP请求对应的响应并通过TCP连接发送回客户端。

Go语言的HTTP标准库提供了非常丰富的功能,很多语言的标准库只提供了最基本的功能,实现HTTP客户端和服务器往往都需要借助其他开源的框架,但是Go语言的很多项目都会直接使用标准库实现HTTP服务器,这也从侧面说明了Go语言标准库的价值。

© 2026 我的博客

🌱 Powered by Hugo with theme Dream.

关于这个博客

关于博客

记录软件开发过程的一些知识和技巧,提升自我

关于博主

除了才华一无所有~~ 薪尽自然凉~~ 强迫症患者~~ 热爱古风~~