彭诗亮的博客

0%

gin路由请求数据解析

发表于

net/http 路由解析

在了解gin的路由解析过程之前，我们有必要先了解下go的net/http的工作流程

首先，http是如何建立起来的?
img.png

在http.ListenAndServe的代码执行流程中，我们可以获取到上面的代码执行流程:

创建 socket

1
2
3
4
5
6
7
8
func (srv *Server) ListenAndServe() error {
    // ... 省略代码
    ln, err := net.Listen("tcp", addr) // <-----看这里listen
    if err != nil {
      return err
    }
    return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}

Accept 等待客户端链接

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
// net/http/server.go:L2805-2853
func (srv *Server) Serve(l net.Listener) error {
    // ... 省略代码
    for {
      rw, e := l.Accept() // <----- 看这里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) // <--- 看这里
    }
}
3. 提供回调

read or write

在c.serve中执行c.readRequest会调用read读取请求数据

1
2
3
4
5
6
7
8
9
10
11
12
func (c *conn) serve(ctx context.Context) {
	// ...省略代码
	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, runHooks)
        }
        // ...省略代码
        serverHandler{c.server}.ServeHTTP(w, w.req)
    }
}

在ServeHTTP中的ResponseWriter会调用write返回响应数据给客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    handler := sh.srv.Handler
    if handler == nil {
        handler = DefaultServeMux
    }
    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)
}

这基本是整个过程的代码了

  1. ln, err := net.Listen("tcp", addr)做了初试化了socket, bind, listen的操作.
  2. rw, e := l.Accept()进行accept, 等待客户端进行连接
  3. go c.serve(ctx) 启动新的goroutine来处理本次请求. 同时主goroutine继续等待客户端连接, 进行高并发操作
  4. h, _ := mux.Handler(r) 获取注册的路由, 然后拿到这个路由的handler, 然后将处理结果返回给客户端

路由注册

net/http是通过server mux来管理路由解析的

先从最基本的路由注册实例开始

1
2
3
http.HandleFunc("/api/hello/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
})
1
2
3
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func (mux *ServeMux) Handle(pattern string, handler Handler) {
	mux.mu.Lock()
	defer mux.mu.Unlock()
	
    // ...省略代码

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

通过上述追踪可以看到mux将api/hello注册到mux.m中，mux.m是一个加锁的map,也就是通过map的key存储具体的路由前缀(parttern)来匹配对应的路由

1
2
3
4
5
6
type ServeMux struct {
	mu    sync.RWMutex
	m     map[string]muxEntry
	es    []muxEntry // slice of entries sorted from longest to shortest.
	hosts bool       // whether any patterns contain hostnames
}

在下面这段代码中可以看到，mux会分析注册进来的新路由是否以’/‘结尾,如果是会加该parttern入到es中

1
2
3
4
mux.m[pattern] = e
if pattern[len(pattern)-1] == '/' {
    mux.es = appendSorted(mux.es, e)
}

appendSorted详细逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func appendSorted(es []muxEntry, e muxEntry) []muxEntry {
	n := len(es)
	i := sort.Search(n, func(i int) bool {
		return len(es[i].pattern) < len(e.pattern)
	})
	if i == n {
		return append(es, e)
	}
	// we now know that i points at where we want to insert
	es = append(es, muxEntry{}) // try to grow the slice in place, any entry works.
	copy(es[i+1:], es[i:])      // Move shorter entries down
	es[i] = e
	return es
}

在es中，api前缀的加入是根据parttern的len递减顺序来进行存储的

1
2
3
4
5
6
7
8
9
10
11
12
http.HandleFunc("/api/hello/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
})
http.HandleFunc("/api/hello1/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
})
http.HandleFunc("/api/hello12/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
})
http.HandleFunc("/api/hello3/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
})

es append的输出过程是这样的

1
2
3
4
[{0x1315f00 /api/hello/}]
[{0x1315fa0 /api/hello1/} {0x1315f00 /api/hello/}]
[{0x1316040 /api/hello12/} {0x1315fa0 /api/hello1/} {0x1315f00 /api/hello/}]
[{0x1316040 /api/hello12/} {0x1315fa0 /api/hello1/} {0x13160e0 /api/hello3/} {0x1315f00 /api/hello/}]

为什么要按照这种顺序呢，当注册一个以/为结尾的路由，mux会尽可能去按照最大长度来匹配路由规则，如果匹配到了，即使后面的部分还有其他字符，也会按照当前匹配的handler去处理逻辑
所以，对于/api/hello/和/api/hello/1111拿到的handler是一样的，而不是以/为结尾注册后的路由，会按照全部parttern去匹配

自定义路由注册

通过net/http包的路由管理模式我们可以知道，net/http的路由匹配根本就不符合 RESTful 的规则，遇到稍微复杂一点的需求时，这个简单的路由匹配规则简直就是噩梦。
所以net/http提供了自定义路由管理模式

1
2
3
if err := http.ListenAndServe(":8000", nil); err != nil {
    fmt.Println("start http server fail:", err)
}

在ListenAndServe的第二个参数会传递用户自定义的handler，如果为nil，那么会使用DefaultServeMux也就是net/http的路由管理模式来进行管理

在下面的这段代码有具体逻辑展示

1
2
3
4
5
6
7
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    handler := sh.srv.Handler
    if handler == nil {
        handler = DefaultServeMux
    }
    // ...省略
}

我们可以总结下net/http的请求处理流程
img_2.png

而gin正是通过注册了自己的路由handler，即engine.Handler()来实现自定义管理

1
2
3
4
5
6
7
8
9
10
11
12
13
func (engine *Engine) Run(addr ...string) (err error) {
	defer func() { debugPrintError(err) }()

	if engine.isUnsafeTrustedProxies() {
		debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
			"Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.")
	}

	address := resolveAddress(addr)
	debugPrint("Listening and serving HTTP on %s\n", address)
	err = http.ListenAndServe(address, engine.Handler())
	return
}

gin的请求处理流程
img_1.png

所以我们只需要关心engine的实现和engine的ServerHttp实现，数据请求流程还是跟net/http是一样的

1
2
3
4
5
6
7
8
9
10
11
// ServeHTTP conforms to the http.Handler interface.
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	c := engine.pool.Get().(*Context)
	c.writermem.reset(w)
	c.Request = req
	c.reset()

	engine.handleHTTPRequest(c)

	engine.pool.Put(c)
}

ServeHTTP的实现流程可以总结为:

  1. 从 sync.pool 里面拿去一块内存
  2. 对这块内存做初始化工作，防止数据污染
  3. 处理请求 handleHTTPRequest
  4. 请求处理完成后，把这块内存归还到 sync.pool 中