最近看很多公司大部分项目开始往golang换, restful api的框架选定基本上都使用gin、beego, 于是最近将 gin的源码看了一遍, 最近会用几篇文章将gin框架的的流程及注意事项做一个梳理, 下面进入正题。

gin框架预览

gin
	context.go
	gin.go
	recovery.go
	response_writer.go
	routergroup.go
	tree.go
	utils.go
	debug.go
	binding
	render
	other...

上图大概是 gin里面比较重要的模块. 从 gin的官方第一个demo入手.

package main

import "github.com/gin-gonic/gin"

func main() {    
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
            })
        })    
    r.Run() // listen and serve on 0.0.0.0:8080
}

r.Run()的源码:

// Run attaches the router to a http.Server and starts listening and serving HTTP requests.
// It is a shortcut for http.ListenAndServe(addr, router)
// Note: this method will block the calling goroutine indefinitely unless an error happens.
func (engine *Engine) Run(addr ...string) (err error) {
	defer func() { debugPrintError(err) }()

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

然后看到开始调用的是 http.ListenAndServe(address,engine), 这个函数是 net/http的函数. 然后请求数据就在 net/http开始流转.

所以, gin源码阅读系列就是要弄明白以下几个问题:

  1. request数据是如何流转的
  2. gin框架到底扮演了什么角色
  3. 请求从gin流入net/http, 最后又是如何回到gin中
  4. gin的context为何能承担起来复杂的需求
  5. gin的路由算法
  6. gin的中间件是什么
  7. gin的Engine具体是个什么东西
  8. net/http的requeset, response都提供了哪些有用的东西

request数据是如何流转的

先不使用 gin, 直接使用 net/http来处理http请求

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

在浏览器中输入 localhost:8000, 会看到 HelloWorld. 下面利用这个简单demo看下 request的流转流程.

HTTP是如何建立起来的

简单的说一下http请求是如何建立起来的(需要有基本的网络基础, 可以找相关的书籍查看, 推荐看 UNIX网络编程卷1:套接字联网API)

socket编程

TCP/IP五层模型下, HTTP位于 应用层, 需要有 传输层来承载 HTTP协议. 传输层比较常见的协议是 TCP, UDP, SCTP等. 由于 UDP不可靠, SCTP有自己特殊的运用场景, 所以一般情况下 HTTP是由 TCP协议承载的(可以使用wireshark抓包然后查看各层协议)

使用 TCP协议的话, 就会涉及到 TCP是如何建立起来的. 面试中能够常遇到的名词 三次握手, 四次挥手就是在这里产生的. 具体的建立流程就不在陈述了, 大概流程就是图中左半边

所以说, 要想能够对客户端http请求进行回应的话, 就首先需要建立起来TCP连接, 也就是 socket. 下面要看下 net/http是如何建立起来 socket?

net/http是如何建立 socket

从图上可以看出, 不管server代码如何封装, 都离不开 bind, listen, accept这些函数. 就从上面这个简单的demo入手查看源码.

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

注册路由

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("Hello World")) })

这段代码是在注册一个路由及这个路由的handler到 DefaultServeMux

// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
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
	}
}

可以看到这个路由注册太过简单了, 也就给 gin, iris, echo等框架留下了扩展的空间, 后面详细说这个东西

服务监听及响应

上面路由已经注册到 net/http了, 下面就该如何建立socket了, 以及最后又如何取到已经注册到的路由, 将正确的响应信息从handler中取出来返回给客户端

	if err := http.ListenAndServe(":8000", nil); err != nil {
		fmt.Println("start http server fail:", err)
	}
	
// net/http/server.go:L2813-2826
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)
}

		rw, e := l.Accept()
		go c.serve(connCtx)
		
		serverHandler{c.server}.ServeHTTP(w, w.req)
		
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)
}		

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

  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基本上提供了全套的服务.

为什么会出现很多go框架

// 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.  mux.es contains all patterns
	// that end in / sorted from longest to shortest.
	for _, e := range mux.es {
		if strings.HasPrefix(path, e.pattern) {
			return e.h, e.pattern
		}
	}
	return nil, ""
}

从这段函数可以看出来, 匹配规则过于简单, 当能匹配到路由的时候就返回其对应的handler, 当不能匹配到时就返回 /. 所以 net/http的路由匹配无法满足复杂的需求开发. 所以基本所有的go框架干的最主要的一件事情就是重写 net/http的route

所以我们直接说 gin就是一个httprouter也不过分, 当然 gin也提供了其他比较主要的功能, 后面会一一介绍

还有一个go框架要实现的东西是 http.ResponseWriter

综述, net/http基本已经提供 http服务的70%的功能, 那些号称贼快的go框架, 基本上都是提供一些功能, 让我们能够更好的处理客户端发来的请求.