ServeMux 详解

在 Go 语言中,创建一个 HTTP 服务很简单,只需要几行代码就可以创建一个可用的 HTTP 服务,这是因为 Go 原生帮我们实现了一个默认的 HTTP 服务,就是 ServeMux,在这篇文章中,我们来详细看一下 ServeMux 的具体实现。

1. 创建一个 HTTP 服务

在 Go 语言中,创建一个 HTTP 服务只需要写下面几行代码就可以了。

1
2
3
4
5
6
7
8
func main() {

http.HandleFunc("/index", func(writer http.ResponseWriter, request *http.Request) {
writer.Write([]byte("Hello go web"))
})

http.ListenAndServe(":8080", nil)
}

我们定义了一个路由,然后启动 HTTP 服务,就可以在浏览器中通过 http://127.0.0.1:8080/index 来访问服务,服务端会返回 Hello go web

这样,一个简单的 HTTP 服务就创建完成了。

2. HTTP 服务如何运行

上面的代码有两部分,一部分是定义 HTTP 服务的路由,在服务启动之后,我们访问相应的路由,就能得到服务端的响应。

在 http 包中,有一个接口 http.Handler ,这个接口是 HTTP 服务的核心:

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

对于 HTTP 服务来说,一定发起请求的客服端和处理请求的服务端,客户端发起一个请求,然后服务端给出相应的输出。这个 Handler 接口就把这个整个过程抽象为 ServeHTTP 方法。ResponseWriter 表示服务端的输出,Request 表示来自客户端的请求。

在 http 包中提供了一个 Handler 的实现 ServeMux,这个Handler 做的事情也很简单,就是来维护 URL 和 Handler 之间的关系,根据 URL 判断应该把请求转发到哪个 Handler,没错这里的 Handler 也是 http.Handler,是同一个接口。用 http.Handler 来管理 http.Handler,我觉得这是一个非常优雅的设计。

2.1 定义路由

路由可以使用两种方式来定义,一种是实现 Handler,还有一种是使用 HandleFunc,这两个概念在上一篇文章中我们已经详细讨论过了,这里就不多说。

示例代码中的路由使用 HandleFunc 来定义,这里我们来看一下路由具体是如何被定义的。我们进入 HandleFunc 的源码:

1
2
3
4
// server.go
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}

发现实际上是调用了 DefaultServerMux 的 HandleFunc 方法,DefaultServerMux 实际上就是 ServeMux,是 Go 的 HTTP 服务的默认实现。然后 DefaultServerMux 调用 Handle 方法来处理路由:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// server.go
func (mux *ServeMux) Handle(pattern string, handler Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()

if pattern == "" {
panic("http: invalid pattern")
}
if handler == nil {
panic("http: nil handler")
}
if _, exist := mux.m[pattern]; exist {
panic("http: multiple registrations for " + pattern)
}

if mux.m == nil {
mux.m = make(map[string]muxEntry)
}
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
}
}

路由由两部分组成,一个是匹配 HTTP url 的 pattern,每个pattern 都代表着一类 HTTP 请求,都需要一个对应的 handler 来处理。

DefaultServerMux 的 Handle 方法其实就做了一件事,在判断路由和对应的 handler 实现都没问题,并且该路由没有重复定义之后,就把这些路由都存到 map 中。所以 HTTP 服务的路由表其实就是一个 map。

完整流程如下,DefaultServerMux 简称为 DSM :

2.2 启动 HTTP 服务

路由定义完成之后,就需要启动服务了,就是下面这行代码:

1
http.ListenAndServe(":8080", nil)

通常,第二个参数都会设置为 nil,设置为 nil 的时候,就会使用 Go 语言默认的 HTTP 服务实现。我们跟进代码的实现:

1
2
3
4
5
// server.go
func ListenAndServe(addr string, handler Handler) error {
server := &Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}

默认情况下,会创建一个 Server,Server 就是表示一个服务端, 其中定义了运行一个 HTTP 服务所需要的全部参数以及必要的方法,如果不给 Server 传入参数 ,那么 Server 就使用默认的参数运行。

1
2
3
4
5
6
7
type Server struct {
// 服务端的 host 和 端口号
Addr string

Handler Handler // 默认为 ServeMux
// 省略其他参数
}

然后 server 会调用 ListenAndServe 来启动端口监听和请求接收,使用 net.Listen 来启动监听端口:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// server.go
func (srv *Server) ListenAndServe() error {
if srv.shuttingDown() {
return ErrServerClosed
}
addr := srv.Addr
if addr == "" {
addr = ":http"
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return err
}
return srv.Serve(ln)
}

然后调用 Server 的 Serve 方法来接收请求和处理请求。在 Serve 方法中,最关键的是下面这段代码,这里是一个 for 循环,没有结束条件,除非发生错误或者主动结束服务,否则会一直处在接收请求的状态。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// server.go#Serve
for {
rw, err := l.Accept()
if err != nil {
select {
case <-srv.getDoneChan():
return ErrServerClosed
default:
}
//......
return err
}
connCtx := ctx
if cc := srv.ConnContext; cc != nil {
connCtx = cc(connCtx, rw)
if connCtx == nil {
panic("ConnContext returned nil")
}
}
tempDelay = 0
c := srv.newConn(rw)
c.setState(c.rwc, StateNew) // before Serve can return
go c.serve(connCtx)
}

接收到请之后,会为每一个请求创建一个 conn 实例,conn 表示服务端的一个 HTTP 连接,并启动一个新的 goroutine 来处理这个请求。

然后就进入到 conn 的 serve 方法。

因为在一个 HTTP 请求中,有可能会出现多次请求的收发,所以这里依然启动了 for 的循环来接收请求数据。

1
2
3
4
5
6
7
8
9
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)
}
// .. 去掉无关代码
serverHandler{c.server}.ServeHTTP(w, w.req)
// .. 去掉无关代码
}

在 conn 的 serve 方法中,其实就只做了两件事,一件事读取请求中的数据。然后是调用 ServeHTTP 方法,进入到 ServeHTTP 方法中:

1
2
3
4
5
6
7
8
9
10
11
// server.go
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)
}

判断 handler 是否为 nil,如果为 nil,然后就直接使用 DefaultServeMux 的 ServeHTTP 方法来处理 HTTP 请求。

1
2
3
4
5
6
7
8
9
10
11
12
// server.go
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)
h.ServeHTTP(w, r)
}

我们发现其实这个方法也只做了一件事,就是去上面路由表 muxEntry 中匹配路由,然后使用路由 的 Handler 调用 ServerHTTP 来真正的处理请求。

完整的流程如下:

3. 小结

Go 服务默认的 HTTP 处理流程其实不难理解,最难的地方在于满屏都是 Handler 接口和 ServeHTTP 方法,理解 Handler 接口是理解整个流程的关键。

所有的 HTTP 请求都需要经过 ServeHTTP 方法处理。而 Go 语言中的 ServeMux 实现了 Handler 接口,通过 url 找到对应的路由,然后在 ServeHTTP 中调用路由实现的 ServeHTTP 方法去真正处理对应的请求。

Go 语言对 HTTP 服务的抽象非常好,通过一个接口就把整个流程串起来了。

文 / Rayjun

© 2020 Rayjun    PowerBy Hexo    京ICP备16051220号-1