目录
一个Go最简单的HTTP服务器:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package main
import (
"fmt"
"net/http"
)
func IndexHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "你好呀！")
}
func main() {
http.HandleFunc("/hi", IndexHandler)
http.ListenAndServe(":8082", nil)
}
|
HTTP
基于 HTTP 构建的网络应用有两个核心部分：client & server, 两个端的交互来自 clinet 的 request，以及server端的response。所谓的http服务器，主要在于如何接受 clinet 的 request，并向client返回response。
HTTP处理流程
client -> resquest -> multiplexer(router) -> handler -> response -> client
So, 理解Go中的HTTP服务，最重要的是理解 Multiplexer(router) 和 Handler, Go 中的 Multiplexer 基于 ServeMux 结构，同时也实现了 Handler 接口。
几个重要接口或结构
- ResponseWriter: 生成response的接口
- Handler：处理请求和生成响应的接口
- ServeMux: 路由，ServeMux也是一种Handler
- Conn: 网络连接
文中的几个重要约定
对于handler的其实没有合适的中文词语，只可意会，不可言传的感觉。为了更好的说明问题，本文约定了如下规则
- Handler函数：具有func(w http.ResponseWriter, r *http.Request) 签名的函数
- Handler处理器(函数)：经过HandlerFunc结构包装的Handler函数，它是实现了ServeHTTP接口方法的函数。调用Handler处理器的ServeHTTP方法时，即调用Handler函数本身。
- Handler对象：实现了Handler接口方法(ServeHTTP)的结构
Handler处理器和Handler对象的差别在于，一个是函数，另一个是结构，他们都实现了ServeHTTP方法。
图1：Handler-Handler处理器
图2：Go-net-http流程图
图3：Go-net-http流程文字描述
Handler
Golang 没有继承、类多态的方式可以通过接口实现。go 的 HTTP 服务都是基于 Handler 进行处理的。
1
2
3
|
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
|
Note: 任何结构体, 只要实现了 ServeHTTP 方法，这个结构体就可以称之为 handler 对象。 ServeMux 会使用 handler 并调用其 ServeHTTP 方法处理请求并返回响应。
ServeMux
1
2
3
4
5
6
7
8
9
10
|
type ServeMux struct {
mu sync.RWMutex
m map[string]muxEntry
hosts bool
}
type muxEntry struct {
h Handler
pattern string
}
|
ServeMux 结构中最重要的字段为 m, 是一个 map, key是一些 url 模式，value 是一个 muxEntry 结构，后者定义存储了具体的 url 模式和 handler
Note: 当然，所谓的 ServeMux 也实现了 ServeHTTP 方法，即实现了 Handler 接口，也算是一个 handler 对象，不过 ServeMux 的 ServeHTTP 方法不是用来处理 request 和 response, 而是用来找到路由注册的 handler 函数的，后面在做解释。
ServeMux 提供的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
// 根据Request获取 Handler 和 URL 模式，内部实现调用私有方法 handler
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)
// 根据 host & path 获取 Handler 和 URL 模式， 内部调用 match 方法
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
// 根据客户端请求的 endpoint_path 在 m[string]muxEntry 迭代寻找 Handler
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
// !! 这个说明，ServeHttp也实现了Handler接口，它实际上也是一个Handler！内部实现调用handler
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)
// 注册handler方法（直接使用func注册）, 内部调用 Handle
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))
// 注册 handler 方法, 即将 key=pattern & value=muxEntry{h: handler, pattern: pattern} 添加到 mux.m 映射中
func (mux *ServeMux) Handle(pattern string, handler Handler)
|
Server
处理 ServeMux 和 Handler, 还有一个结构 Server 需要了解。 从 http.ListenAndServe 的源码可以看出， 它创建了一个 server 对象，并调用 server 对象的 ListenAndServe 方法：
1
2
3
4
|
func ListenAndServe(addr string, handler Handler) error {
server := &Server{Addr: addr, Handler: handler}
return serve.ListenAndServe()
}
|
Server 结构定义如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
type Server struct {
Addr string
Handler Handler
ReadTimeout time.Duration
WriteTimeout time.Duration
TLSConfig *tls.Config
MaxHeaderBytes int
TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
ConnState func(net.Conn, ConnState)
ErrorLog *log.Logger
disableKeepAlives int32
nextProtoOnce sync.Once
nextProtoErr error
}
|
Server 结构存储了服务器处理请求常见的字段。其中 Handler 字段也保留 Handler 接口。 如果 Server 接口没有提供 Handler 结构对象，那么会使用 DefaultServeMux 做 multiplexer
创建 HTTP 服务
创建一个 HTTP 服务， 大概需要经理两个过程，首先需要注册路由，即提供 url 模式和 handler 函数的映射，其次就是实例化一个 server 对象，并开启对客户端的监听
再看 go http 服务源码：
注册路由
1
|
http.HandleFunc("/hi", IndexHandler)
|
监听请求
1
|
http.ListenAndServe(":8082", nil)
|
注册路由
阅读框架源码是学习的好方式，通常阅读也有两个方法，一是不求甚解，框架的主要流程要清晰，别的细枝末节，如果尚不能理解作者的用意，可以先忽略，不必马上深究；其次，庖丁解牛，对于作者想要表达的主要流程，一定要明确，执行的逻辑和结构。两者看起来略矛盾，其实不然。大体而言就是对主流程要清晰，主流程以外的细节需要先忽略。最简单实践方式就是，看不懂的就先放一边。直到所有的都看不懂，再回去看以前不懂的部分，搞懂为止。下面就查看http是如何注册路由。
net/http 包暴露的注册路由API很简单，http.HandleFunc 选取了 DefaultServeMux 作为 multiplexer:
1
2
3
|
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
|
那么什么是 DefaultServeMux 呢？ 实际上，DefaultServeMux 是 ServeMux 的一个实例，当然 http 包也提供了 NewServeMux 方法创建一个 ServeMux 实例，默认则创建一个 DefaultServeMux：
1
2
3
4
5
6
7
|
// NewServeMux allocates and return a new ServeMux
func NewServeMux() *ServeMux {return new(ServeMux)}
// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux
|
Note: go创建实例的过程中，也可以使用指针方式，即
1
2
3
4
5
6
7
8
9
10
11
12
13
|
> type Server struct{}
> server := Server{}
> // 和下面的一样都可以创建Server的实例
> var DefalutServer Server
> var server = &DefalutServer
> ```
> 因此DefaultServeMux的HandleFunc(pattern, handler)方法实际是定义在ServeMux下的：
```go
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
mux.Handle(pattern, HandlerFunc(handler))
}
|
Note: 上述代码中的 HandlerFunc 是一个函数类型。同时实现了 Handler 接口的 ServeHTTP 方法。使用 HandlerFunc 类型包装一下路由定义的 IndexHandler 函数，其目的就是为了让这个函数也实现 ServeHTTP 方法，即转变成一个 handler 处理器(函数)。
1
2
3
4
5
6
|
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
|
一旦这样处理，就意味着我们的 IndexHandler 函数也有了 ServeHTTP 方法。此外，ServeMux 的 Handle 方法，将会对 pattern 和 handler 函数做一个 map 映射。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
func (mux *ServeMux) Handle(pattern string, handler Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()
if pattern == "" {
panic("http: invalid pattern " + 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)
}
mux.m[pattern] = muxEntry{h: handler, pattern: pattern}
if pattern[0] != "/" {
mux.hosts = true
}
}
|
由此可见，Handle 函数的主要目的在于把 handler 和 pattern 模式绑定到 map[string]muxEntry 的map上，其中 muxEntry 保存了更多的 pattern 和 handler 信息，还记得前面讨论的Server结构吗？ Serve 的 m 字段就是 map[string]muxEntry 这样一个 map
此时，pattern 和 handler 的路由注册完成。 接下来就是如何开始 server 的监听，以接收客户端的请求
服务监听
注册好路由后，启动 web 服务还需要开启服务监听。http 的 ListenAndServe 方法中可以看到创建了一个 Server 对象，并调用了 Server 对象的同名方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
func ListenAndServe(addr string, handler Handler) {
server := &Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}
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{TCPListener: ln.(*tcp.TCPListener)})
}
|
Server 的 ListenAndServe 方法中，会初始化监听地址 Addr, 同时调用 Listen 方法设置监听。最后将监听的 TCP 对象传入到 Serve 方法中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
func (srv *Server) Serve (l net.Listener) error {
defer l.Close()
// ...
baseCtx := context.Backgroud()
ctx := context.WithValue(baseCtx, ServerContextKey, srv)
for {
rw, e := l.Accept()
// ...
c := srv.newConn(rw)
c.setState(c.rwc, StateNew) // before Serve can return
go c.serve(ctx)
}
}
|
Serve 方法比较长，其主要职能就是：
- 创建一个上下文对象
- 然后调用 Listener 的 Accept 方法用来获取连接数据并使用 newConn 方法创建连接对象
- 最后使用 goroutine 协程的方式处理连接请求。
处理请求
监听开启之后，一旦客户端请求到底，go 就开始一个协成处理请求，主要逻辑都在 c.serve(ctx) 方法中
因为每一个连接都开启了一个协程，请求的上下文环境都不同，同时有保证了 go 的高并发。serve 也是一个长长的方法：
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
func (c *conn) serve (ctx context.Context) {
c.remote.Addr = c.rwc.RemoteAddr().String()
defer func() {
if err := recover(); err != nil {
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)
}
}()
//...
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)
w.cancelCtx()
if c.hijacked() {
return
}
w.finishRequest()
if !w.shouldReuseConnection() {
if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
c.closeWriteAndWait()
}
return
}
c.setState(c.rwc, StateIdle)
c.curReq.Store((*response)(nil))
}
|
尽管 serve 很长，里面的结果和逻辑还是很清晰的，使用 defer 定义了 函数退出时，连接关闭相关的处理。然后就是读取连接的网络数据，并处理读取完毕时的状态。接下来就是调用 serverHandler{c.server}.ServeHTTP(w, w.req) 方法处理请求了。 最后就是请求处理完毕的逻辑。serverHandler 是一个重要的结构，它仅有一个字段，即 Server 结构，同时他也实现了 Handler 接口的方法 ServeHTTP, 并在该接口方法中做了一个重要的事情，初始化 multiplexer 路由多路复用器。 如果 server 对象没有指定 Handler，则使用默认的 DefaultServeMux 作为路由 Multiplexer。并调用初始化 Handler 的ServeHTTP 方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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)
}
|
这里 DefaultServeMux 的 ServeHTTP 方法其实也是定义在 ServeMux 结构中的，相关代码如下：
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
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)
}
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
// CONNECT requests are not canonicalized.
if r.Method == "CONNECT" {
// If r.URL.Path is /tree and its handler is not registered,
// the /tree -> /tree/ redirect applies to CONNECT requests
// but the path canonicalization does not.
if u, ok := mux.redirectToPathSlash(r.URL.Host, r.URL.Path, r.URL); ok {
return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
}
return mux.handler(r.Host, r.URL.Path)
}
// All other requests have any port stripped and path cleaned
// before passing to mux.handler.
host := stripHostPort(r.Host)
path := cleanPath(r.URL.Path)
// If the given path is /tree and its handler is not registered,
// redirect for /tree/.
if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok {
return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
}
if path != r.URL.Path {
_, pattern = mux.handler(host, path)
url := *r.URL
url.Path = path
return RedirectHandler(url.String(), StatusMovedPermanently), pattern
}
return mux.handler(host, r.URL.Path)
}
// handler is the main implementation of Handler.
// The path is known to be in canonical form, except for CONNECT methods.
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
mux.mu.RLock()
defer mux.mu.RUnlock()
// Host-specific pattern takes precedence over generic ones
if mux.hosts {
h, pattern = mux.match(host + path)
}
if h == nil {
h, pattern = mux.match(path)
}
if h == nil {
h, pattern = NotFoundHandler(), ""
}
return
}
// Find a handler on a handler map given a path string.
// Most-specific (longest) pattern wins.
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
// Check for exact match first.
v, ok := mux.m[path]
if ok {
return v.h, v.pattern
}
// Check for longest valid match.
var n = 0
for k, v := range mux.m {
if !pathMatch(k, path) {
continue
}
if h == nil || len(k) > n {
n = len(k)
h = v.h
pattern = v.pattern
}
}
return
}
|
mux 的 ServeHTTP 方法通过调用其 Handler 方法寻找注册到路由上的 Handler 函数，并调用该函数的 ServeHTTP 方法，本例则是 IndexHandler 函数。
mux 的 Handler 方法对 URL 简单的处理，然后调用 handler 方法，后者会创建一个锁，同时调用 match 方法返回一个 handler 和 pattern。
mux 的 match 方法中，字段 m 是一个 map[string]muxEntry, 后者存储了 pattern 和 handler 处理器函数，因此通过迭代 m 寻找出注册到路由的 pattern 模式与实际 url 匹配的 handler 函数并返回
返回的结构一直传递到 mux 的 ServeHTTP 方法，接下来调用 handler 函数的 ServeHTTP 方法，即 IndexHandler 函数， 然后把 response 写到 http.RequestWriter 对象返回给客户端。
上述函数运行结束，即 serverHandler{c.server}.ServeHTTP(w, w.rep) 运行结束。 接下来就是对请求处理完毕之后，希望和连接断开的相关逻辑
至此，Golang 中一个完整的 HTTP 服务介绍完毕，包括注册路由，开启监听，处理连接，路由处理函数
总结
多数的 web 应用基于 http 协议，客户端和服务器通过 request-response 的方式交互。一个 server 并不可少的两部分莫过于路由注册和连接处理。Golang 通过一个 ServeMux 实现了 multiplexer 路由多路复用器来管理路由。同时提供一个 Handler 接口提供 ServeHTTP 用来实现 handler 处理其函数，后者可以处理实际 request 并构造 response。
ServeMux 和 handler 处理其函数的连接桥梁是 Handler 接口。ServeMux 的 ServeHTTP 方法实现了寻找注册路由的 handler 函数，并调用该函数 handler 的 ServeHTTP 方法。ServeHTTP 方法就是正真处理请求和构造响应的地方。
回顾 go 的 http 包实现 http 服务器的流程，可见大师们的编码设计之功力。学习有利提高自身的代码逻辑组织能力。更好的学习方式除了阅读，就是实践，接下来，我们将着重讨论来构建http服务。尤其是构建http中间件函数。
http.ServeMux局限性
- 不能够根据请求方法路由
- 处理每次请求，会便利一遍字典，性能不好
- 不支持动态路由，URL里面的路径参数需要自己解析PATH完成
- 根据最长匹配来分发路由，存在一个请求有潜在多个接收者的情况
See Also
Thanks to the authors 🙂
返回目录
