超文本传输协议(Hypertext Transfer Protocol、HTTP 协议)是今天使用最广泛的应用层协议,1989 年由 Tim Berners-Lee 在 CERN 起草的协议已经成为了互联网的数据传输的核心1。在过去几年的时间里,HTTP/2 和 HTTP/3 也对现有的协议进行了更新,提供更加安全和快速的传输功能。多数的编程语言都会在标准库中实现 HTTP/1.1 和 HTTP/2.0 已满足工程师的日常开发需求,今天要介绍的 Go 语言的网络库也实现了这两个大版本的 HTTP 协议。
设计原理
HTTP 协议是应用层协议,在通常情况下我们都会使用 TCP 作为底层的传输层协议传输数据包,但是 HTTP/3 在 UDP 协议上实现了新的传输层协议 QUIC 并使用 QUIC 传输数据,这也意味着 HTTP 既可以跑在 TCP 上,也可以跑在 UDP 上。
图 9-5 HTTP 与传输层协议
Go 语言标准库通过 net/http
包提供 HTTP 的客户端和服务端实现,在分析内部的实现原理之前,我们先来了解一下 HTTP 协议相关的一些设计以及标准库内部的层级结构和模块之间的关系。
请求和响应
HTTP 协议中最常见的概念是 HTTP 请求与响应,我们可以将它们理解成客户端和服务端之间传递的消息,客户端向服务端发送 HTTP 请求,服务端收到 HTTP 请求后会做出计算后以 HTTP 响应的形式发送给客户端。
图 9-6 HTTP 请求与响应
与其他的二进制协议不同,作为文本传输协议,HTTP 协议的协议头都是文本数据,HTTP 请求头的首行会包含请求的方法、路径和协议版本,接下来是多个 HTTP 协议头以及携带的负载。
1 | GET / HTTP/1.1 |
HTTP 响应也有着比较类似的结构,其中也包含响应的协议版本、状态码、响应头以及负载,在这里就不展开介绍了。
消息边界
HTTP 协议目前主要还是跑在 TCP 协议上的,TCP 协议是面向连接的、可靠的、基于字节流的传输层通信协议2,应用层交给 TCP 协议的数据并不会以消息为单位向目的主机传输,这些数据在某些情况下会被组合成一个数据段发送给目标的主机3。因为 TCP 协议是基于字节流的,所以基于 TCP 协议的应用层协议都需要自己划分消息的边界。
图 9-7 实现消息边界的方法
在应用层协议中,最常见的两种解决方案是基于长度或者基于终结符(Delimiter)。HTTP 协议其实同时实现了上述两种方案,在多数情况下 HTTP 协议都会在协议头中加入 Content-Length
表示负载的长度,消息的接收者解析到该协议头之后就可以确定当前 HTTP 请求/响应结束的位置,分离不同的 HTTP 消息,下面就是一个使用 Content-Length
划分消息边界的例子:
1 | HTTP/1.1 200 OK |
不过 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 服务器响应客户端的请求:
1 | type RoundTripper interface { |
HTTP 请求的接收方可以实现 net/http.Handler
接口,其中实现了处理 HTTP 请求的逻辑,处理的过程中会调用 net/http.ResponseWriter
接口的方法构造 HTTP 响应,它提供的三个接口 Header
、Write
和 WriteHeader
分别会获取 HTTP 响应、将数据写入负载以及写入响应头:
1 | type Handler interface { |
客户端和服务端面对的都是双向的 HTTP 请求与响应,客户端构建请求并等待响应,服务端处理请求并返回响应。HTTP 请求和响应在标准库中不止有一种实现,它们都包含了层级结构,标准库中的 net/http.RoundTripper
包含如下所示的层级结构:
图 9-8 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:
图 9-9 事务和 Cookie
事务和 Cookie 是我们在 HTTP 客户端包为我们提供的两个最重要模块,本节将从 HTTP GET 请求开始,按照构建请求、数据传输、获取连接以及等待响应几个模块分析客户端的实现原理。当我们调用 net/http.Client.Get
发出 HTTP 时,会按照如下的步骤执行:
- 调用
net/http.NewRequest
根据方法名、URL 和请求体构建请求; - 调用
net/http.Transport.RoundTrip
开启 HTTP 事务、获取连接并发送请求; - 在 HTTP 持久连接的
net/http.persistConn.readLoop
方法中等待响应;
图 9-10 客户端的几大结构体
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 响应的引用:
1 | type Request struct { |
net/http.NewRequest
是标准库提供的用于创建请求的方法,这个方法会校验 HTTP 请求的字段并根据输入的参数拼装成新的请求结构体。
1 | func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) { |
请求拼装的过程比较简单,它会检查并校验输入的方法、URL 以及负载,然而初始化了新的 net/http.Request
结构,处理负载的过程稍微有一些复杂,我们会根据负载的类型不同,使用不同的方法将它们包装成 io.ReadCloser
类型。
开启事务
当我们使用标准库构建了 HTTP 请求之后,会开启 HTTP 事务发送 HTTP 请求并等待远程的响应,经过下面一连串的调用,我们最终来到了标准库实现底层 HTTP 协议的结构体 — net/http.Transport
:
net/http.Client.Do
net/http.Client.do
net/http.Client.send
net/http.send
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 中的协议选择对应的实现来替代默认的逻辑:
1 | func (t *Transport) roundTrip(req *Request) (*Response, error) { |
在默认情况下,我们都会使用 net/http.persistConn
持久连接处理 HTTP 请求,该方法会先获取用于发送请求的连接,随后调用 net/http.persistConn.roundTrip
:
1 | func (t *Transport) roundTrip(req *Request) (*Response, error) { |
net/http.Transport.getConn
是获取连接的方法,该方法会通过两种方法获取用于发送请求的连接:
1 | func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) { |
- 调用
net/http.Transport.queueForIdleConn
在队列中等待闲置的连接; - 调用
net/http.Transport.queueForDial
在队列中等待建立新的连接;
连接是一种相对比较昂贵的资源,如果在每次发出 HTTP 请求之前都建立新的连接,可能会消耗比较多的时间,带来较大的额外开销,通过连接池对资源进行分配和复用可以有效地提高 HTTP 请求的整体性能,多数的网络库客户端都会采取类似的策略来复用资源。
当我们调用 net/http.Transport.queueForDial
尝试与远程建立连接时,标准库会在内部启动新的 Goroutine 执行 net/http.Transport.dialConnFor
用于建连,从最终调用的 net/http.Transport.dialConn
中我们能找到 TCP 连接和 net
库的身影:
1 | func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *persistConn, err error) { |
在创建新的 TCP 连接后,我们还会在后台为当前的连接创建两个 Goroutine,分别从 TCP 连接中读取数据或者向 TCP 连接写入数据,从建立连接的过程我们可以发现,如果我们为每一个 HTTP 请求都创建新的连接并启动 Goroutine 处理读写数据,会占用很多的资源。
等待请求
持久的 TCP 连接会实现 net/http.persistConn.roundTrip
处理写入 HTTP 请求并在 select
语句中等待响应的返回:
1 | func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err error) { |
每个 HTTP 请求都由另一个 Goroutine 中的 net/http.persistConn.writeLoop
循环写入的,这两个 Goroutine 独立执行并通过 Channel 进行通信。net/http.Request.write
会根据 net/http.Request
结构中的字段按照 HTTP 协议组成 TCP 数据段:
1 | func (pc *persistConn) writeLoop() { |
当我们调用 net/http.Request.write
向请求中写入数据时,实际上直接写入了 net/http.persistConnWriter
中的 TCP 连接中,TCP 协议栈会负责将 HTTP 请求中的内容发送到目标服务器上:
1 | type persistConnWriter struct { |
持久连接中的另一个读循环 net/http.persistConn.readLoop
会负责从 TCP 连接中读取数据并将数据发送会 HTTP 请求的调用方,真正负责解析 HTTP 协议的还是 net/http.ReadResponse
:
1 | func ReadResponse(r *bufio.Reader, req *Request) (*Response, error) { |
我们在上述方法中可以看到 HTTP 响应结构的大致框架,其中包含状态码、协议版本、请求头等内容,响应体还是在读取循环 net/http.persistConn.readLoop
中根据 HTTP 协议头进行解析的。
服务器
Go 语言标准库 net/http
包提供了非常易用的接口,如下所示,我们可以利用标准库提供的功能快速搭建新的 HTTP 服务:
1 | func handler(w http.ResponseWriter, r *http.Request) { |
上述的 main
函数只调用了两个标准库提供的函数,它们分别是用于注册处理器的 net/http.HandleFunc
函数和用于监听和处理器请求的 net/http.ListenAndServe
,多数的服务器框架都会包含这两类接口,分别负责注册处理器和处理外部请求,这一种非常常见的模式,我们在这里也会按照这两个维度介绍标准库如何支持 HTTP 服务器的实现。
注册处理器
HTTP 服务是由一组实现了 net/http.Handler
接口的处理器组成的,处理 HTTP 请求时会根据请求的路由选择合适的处理器:
当我们直接调用 net/http.HandleFunc
注册处理器时,标准库会使用默认的 HTTP 服务器 net/http.DefaultServeMux
处理请求,该方法会直接调用 net/http.ServeMux.HandleFunc
:
1 | func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) { |
上述方法会将处理器转换成 net/http.Handler
接口类型调用 net/http.ServeMux.Handle
注册处理器:
1 | func (mux *ServeMux) Handle(pattern string, handler Handler) { |
路由和对应的处理器会被组成 net/http.DefaultServeMux
,该结构会持有一个 net/http.muxEntry
哈希,其中存储了从 URL 到处理器的映射关系,HTTP 服务器在处理请求时就会使用该哈希查找处理器。
处理请求
标准库提供的 net/http.ListenAndServe
可以用来监听 TCP 连接并处理请求,该函数会使用传入的监听地址和处理器初始化一个 HTTP 服务器 net/http.Server
,调用该服务器的 net/http.Server.ListenAndServe
方法:
1 | func ListenAndServe(addr string, handler Handler) error { |
net/http.Server.ListenAndServe
会使用网络库提供的 net.Listen
监听对应地址上的 TCP 连接并通过 net/http.Server.Serve
处理客户端的请求:
1 | func (srv *Server) ListenAndServe() error { |
net/http.Server.Serve
会在循环中监听外部的 TCP 连接并为每个连接调用 net/http.Server.newConn
创建新的 net/http.conn
,它是 HTTP 连接的服务端表示:
1 | func (srv *Server) Serve(l net.Listener) error { |
创建了服务端的连接之后,标准库中的实现会为每个 HTTP 请求创建单独的 Goroutine 并在其中调用 net/http.Conn.serve
方法,如果当前 HTTP 服务接收到了海量的请求,会在内部创建大量的 Goroutine,这可能会使整个服务质量明显降低无法处理请求。
1 | func (c *conn) serve(ctx context.Context) { |
上述代码片段是我们简化后的连接处理过程,其中包含读取 HTTP 请求、调用 Handler 处理 HTTP 请求以及调用完成该请求。读取 HTTP 请求会调用 net/http.Conn.readRequest
,该方法会从连接中获取 HTTP 请求并构建一个实现了 net/http.ResponseWriter
接口的变量 net/http.response
,向该结构体写入的数据都会被转发到它持有的缓冲区中:
1 | func (w *response) write(lenData int, dataB []byte, dataS string) (n int, err error) { |
解析了 HTTP 请求并初始化 net/http.ResponseWriter
之后,我们就可以调用 net/http.serverHandler.ServeHTTP
查找处理器来处理 HTTP 请求了:
1 | type serverHandler struct { |
如果当前的 HTTP 服务器中不包含任何处理器,我们会使用默认的 net/http.DefaultServeMux
处理外部的 HTTP 请求。
net/http.ServeMux
是一个 HTTP 请求的多路复用器,它可以接收外部的 HTTP 请求、根据请求的 URL 匹配并调用最合适的处理器:
1 | func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) { |
经过一系列的函数调用,上述过程最终会调用 HTTP 服务器的 net/http.ServerMux.match
,该方法会遍历前面注册过的路由表并根据特定规则进行匹配:
1 | func (mux *ServeMux) match(path string) (h Handler, pattern string) { |
如果请求的路径和路由中的表项匹配成功,我们会调用表项中对应的处理器,处理器中包含的业务逻辑会通过 net/http.ResponseWriter
构建 HTTP 请求对应的响应并通过 TCP 连接发送回客户端。
总结
Go 语言的 HTTP 标准库提供了非常丰富的功能,很多语言的标准库只提供了最基本的功能,实现 HTTP 客户端和服务器往往都需要借助其他开源的框架,但是 Go 语言的很多项目都会直接使用标准库实现 HTTP 服务器,这也从侧面说明了 Go 语言标准库的价值。
Go Http客户端
get请求可以直接http.Get方法
1 | package main |
有时需要在请求的时候设置头参数、cookie之类的数据,就可以使用http.Do方法。
1 | package main |
如果使用http POST方法可以直接使用http.Post 或 http.PostForm,
1 | package main |
http.PostForm方法,
1 | package main |
Go Http服务器端
一切的基础:ServeMux 和 Handler
Go 语言中处理 HTTP 请求主要跟两个东西相关:ServeMux 和 Handler。
ServrMux 本质上是一个 HTTP 请求路由器(或者叫多路复用器,Multiplexor)。它把收到的请求与一组预先定义的 URL 路径列表做对比,然后在匹配到路径的时候调用关联的处理器(Handler)。
处理器(Handler)负责输出HTTP响应的头和正文。任何满足了http.Handler接口的对象都可作为一个处理器。通俗的说,对象只要有个如下签名的ServeHTTP方法即可:
1 | ServeHTTP(http.ResponseWriter, *http.Request) |
Go 语言的 HTTP 包自带了几个函数用作常用处理器,比如FileServer,NotFoundHandler 和 RedirectHandler。我们从一个简单具体的例子开始:
1 | package main |
快速地过一下代码:
- 在 main 函数中我们只用了 http.NewServeMux 函数来创建一个空的 ServeMux。
- 然后我们使用 http.RedirectHandler 函数创建了一个新的处理器,这个处理器会对收到的所有请求,都执行307重定向操作到 http://www.baidu.com。
- 接下来我们使用 ServeMux.Handle 函数将处理器注册到新创建的 ServeMux,所以它在 URL 路径/foo 上收到所有的请求都交给这个处理器。
- 最后我们创建了一个新的服务器,并通过 http.ListenAndServe 函数监听所有进入的请求,通过传递刚才创建的 ServeMux来为请求去匹配对应处理器。
然后在浏览器中访问 http://localhost:3000/foo,你应该能发现请求已经成功的重定向了。
明察秋毫的你应该能注意到一些有意思的事情:ListenAndServer 的函数签名是 ListenAndServe(addr string, handler Handler) ,但是第二个参数我们传递的是个 ServeMux。
我们之所以能这么做,是因为 ServeMux 也有 ServeHTTP 方法,因此它也是个合法的 Handler。
对我来说,将 ServerMux 用作一个特殊的Handler是一种简化。它不是自己输出响应而是将请求传递给注册到它的其他 Handler。这乍一听起来不是什么明显的飞跃 - 但在 Go 中将 Handler 链在一起是非常普遍的用法。
自定义处理器(Custom Handlers)
让我们创建一个自定义的处理器,功能是将以特定格式输出当前的本地时间:
1 | type timeHandler struct { |
这个例子里代码本身并不是重点。
真正的重点是我们有一个对象(本例中就是个timerHandler结构体,但是也可以是一个字符串、一个函数或者任意的东西),我们在这个对象上实现了一个 ServeHTTP(http.ResponseWriter, *http.Request) 签名的方法,这就是我们创建一个处理器所需的全部东西。
我们把这个集成到具体的示例里:
1 | //File: main.go |
main函数中,我们像初始化一个常规的结构体一样,初始化了timeHandler,用 & 符号获得了其地址。随后,像之前的例子一样,我们使用 mux.Handle 函数来将其注册到 ServerMux。
现在当我们运行这个应用,ServerMux 将会将任何对 /time的请求直接交给 timeHandler.ServeHTTP 方法处理。
访问一下这个地址看一下效果:http://localhost:3000/time 。
注意我们可以在多个路由中轻松的复用 timeHandler:
1 | //File: main.go |
将函数作为处理器
对于简单的情况(比如上面的例子),定义个新的有 ServerHTTP 方法的自定义类型有些累赘。我们看一下另外一种方式,我们借助 http.HandlerFunc 类型来让一个常规函数满足作为一个 Handler 接口的条件。
任何有 func(http.ResponseWriter, \http.Request) 签名的函数都能转化为一个 HandlerFunc 类型。这很有用,因为 HandlerFunc 对象内置了 ServeHTTP 方法,后者可以聪明又方便的调用我们最初提供的函数内容。*
让我们使用这个技术重新实现一遍timeHandler应用:
1 | package main |
实际上,将一个函数转换成 HandlerFunc 后注册到 ServeMux 是很普遍的用法,所以 Go 语言为此提供了个便捷方式:ServerMux.HandlerFunc 方法。
我们使用便捷方式重写 main() 函数看起来是这样的:
1 | package main |
绝大多数情况下这种用函数当处理器的方式工作的很好。但是当事情开始变得更复杂的时候,就会有些产生一些限制了。
你可能已经注意到了,跟之前的方式不同,我们不得不将时间格式硬编码到 timeHandler 的方法中。如果我们想从 main() 函数中传递一些信息或者变量给处理器该怎么办?
一个优雅的方式是将我们处理器放到一个闭包中,将我们要使用的变量带进去:
1 | //File: main.go |
timeHandler 函数现在有了个更巧妙的身份。除了把一个函数封装成 Handler(像我们之前做到那样),我们现在使用它来返回一个处理器。这种机制有两个关键点:
首先是创建了一个fn,这是个匿名函数,将 format 变量封装到一个闭包里。闭包的本质让处理器在任何情况下,都可以在本地范围内访问到 format 变量。
其次我们的闭包函数满足 func(http.ResponseWriter, *http.Request) 签名。如果你记得之前我们说的,这意味我们可以将它转换成一个HandlerFunc类型(满足了http.Handler接口)。我们的timeHandler 函数随后转换后的 HandlerFunc 返回。
在上面的例子中我们已经可以传递一个简单的字符串给处理器。但是在实际的应用中可以使用这种方法传递数据库连接、模板组,或者其他应用级的上下文。使用全局变量也是个不错的选择,还能得到额外的好处就是编写更优雅的自包含的处理器以便测试。
你也可能见过相同的写法,像这样:
1 | func timeHandler(format string) http.Handler { |
或者在返回时,使用一个到 HandlerFunc 类型的隐式转换:
1 | func timeHandler(format string) http.HandlerFunc { |
更便利的 DefaultServeMux
你可能已经在很多地方看到过 DefaultServeMux, 从最简单的 Hello World 例子,到 go 语言的源代码中。
我花了很长时间才意识到 DefaultServerMux 并没有什么的特殊的地方。DefaultServerMux 就是我们之前用到的 ServerMux,只是它随着 net/httpp 包初始化的时候被自动初始化了而已。Go 源代码中的相关行如下:
1 | var DefaultServeMux = NewServeMux() |
net/http 包提供了一组快捷方式来配合 DefaultServeMux:http.Handle 和 http.HandleFunc。这些函数与我们之前看过的类似的名称的函数功能一样,唯一的不同是他们将处理器注册到 DefaultServerMux ,而之前我们是注册到自己创建的 ServeMux。
此外,ListenAndServe在没有提供其他的处理器的情况下(也就是第二个参数设成了 nil),内部会使用 DefaultServeMux。
因此,作为最后一个步骤,我们使用 DefaultServeMux 来改写我们的 timeHandler应用:
1 | //File: main.go |