本篇文章是 gin 源码分析系列的第二篇，这篇文章我们主要弄清一个问题：一个请求通过 net/http 的 socket 接收到请求后, 是如何回到 gin 中处理逻辑的？
我们仍然以 net/http 的例子开始

  1. func main() {
  2.     http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  3.         w.Write([]byte("Hello World"))
  4.     })
  6.     if err := http.ListenAndServe(":8000", nil); err != nil {
  7.         fmt.Println("start http server fail:", err)
  8.     }
  9. }


这个例子中 http.HandleFunc 通过看源码，可以看到 URI “/“ 被注册到了 DefaultServeMux 上。

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

net/http ServeHTTP 的作用

net/http 里面有个非常重要的 Handler interface。只有实现了这个方法才能请求的处理逻辑引入自己的处理流程中。

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

默认的 DefaultServeMux 就实现了这个 ServeHTTP
这个 request 的流转过程：

  1. socket.accept 接收到客户端请求后，启动 go c.serve(connCtx)行，专门处理这次请求，server 继续等待客户端连接
  2. 获取能处理这次请求的 handler -> serverHandler{c.server}.ServeHTTP(w, w.req)
  3. 跳转到真正的 ServeHTTP 去匹配路由，获取 handler
  4. 由于并没有自定义路由，于是使用的是 net/http 默认路由
  5. 所以最终调用去 DefaultServeMux 匹配路由，输出返回对应的结果


image.png

探究 gin ServeHTTP 的调用链路

下面是 gin 的官方 demo, 仅仅几行代码，就启动了一个 echo server。

  1. package main
  3. import "github.com/gin-gonic/gin"
  5. func main() {
  6.     r := gin.Default()
  7.     r.GET("/ping", func(c *gin.Context) {
  8.         c.JSON(200, gin.H{
  9.             "message": "pong",
  10.         })
  11.     })
  12.     r.Run() // listen and serve on 0.0.0.0:8080
  13. }

这段代码的大概流程:

  1. r := gin.Default() 初始化了相关的参数
  2. 将路由 /ping 以及对应的 handler 注册到路由树中
  3. 使用 r.Run() 启动 server

r.Run 的底层依然是 http.ListenAndServe

  1. func (engine *Engine) Run(addr ...string) (err error) {
  2.     defer func() { debugPrintError(err) }()
  4.     trustedCIDRs, err := engine.prepareTrustedCIDRs()
  5.     if err != nil {
  6.         return err
  7.     }
  8.     engine.trustedCIDRs = trustedCIDRs
  9.     address := resolveAddress(addr)
  10.     debugPrint("Listening and serving HTTP on %s\n", address)
  11.     err = http.ListenAndServe(address, engine)
  12.     return
  13. }

所以 gin 建立 socket 的过程，accept 客户端请求的过程与 net/http 没有差别，会同样重复上面的过程。唯一有差别的位置就是在于获取 ServeHTTP 的位置

  1. func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
  2.     // 使用gin框架，这路的handler 就是engine
  3.     // 这是http.ListenAndServe的第二个参数
  4.     handler := sh.srv.Handler
  5.     if handler == nil {
  6.         handler = DefaultServeMux
  7.     }
  8.     if req.RequestURI == "*" && req.Method == "OPTIONS" {
  9.         handler = globalOptionsHandler{}
  10.     }
  11.     handler.ServeHTTP(rw, req)
  12. }

由于 sh.srv.Handler 是 interface 类型，但是其真正的类型是 gin.Engine，根据 interace 的动态转发特性，最终会跳转到 gin.Engine.ServeHTTP 函数中。
image.png

gin.ServeHTTP 的实现

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

至此，终于我们看到了 gin.ServeHTTP 的全貌了

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

现在看起来这个实现很简单，其实不然，这才是 gin 能够处理数据的第一步，也仅仅将请求流转入 gin 的处理流程而已。