最近有使用gin-vue-admin框架来做一个管理后台，笔者注意到获取参数有个这样的方法：c.ShouldBindJSON() ,这样一个获取参数的方法，当然这个方法是针对post方式提交数据，于是比较好奇这个是怎么实现的，分以下两步：
数据写入Context;
从Context读取数据；
首先我们写代码的时候会给路由函数带上一个参数(c*gin.Context)， 首先这个是个固定的写法，因为gin关于http请求的handler 方法是定义是需要传入这样一个参数，下面看下源码：
//我们在设置我们的路由一般都是这样写的，这里举几个例子
{
goodsManageRouter.POST("goodsList", goodsManageApi.GetGoodsList)
goodsManageRouter.GET("goodsDetail", goodsManageApi.GoodsDetail)
goodsManageRouter.POST("addGoods", goodsManageApi.AddGoods)
}
//真正处理的函数一般这样写
func(g *GoodsManageApi) GetGoodsList(c *gin.Context){
params := request.GoodsListReq{}
// s := c.Query("name")
_ = c.ShouldBindJSON(¶ms)
...
}
//这里举两个例子POST和GET方法，这两个方法实际都是注册路由，其中handlers 这个参数是
//HandlerFunc 类型的
// POST is a shortcut for router.Handle("POST", path, handle).
type HandlerFunc func(*Context) //表示参数的类型是Context指针类型
func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodPost, relativePath, handlers)
}
// GET is a shortcut for router.Handle("GET", path, handle).
func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodGet, relativePath, handlers)
}
从以上代码我们知道为啥会是带c *gin.Context 参数这种固定写法了。但是我们还是不知道数据是怎么写入到这个c里面的，如果想要了解这些，我们需要从服务(这里是http服务)的运行到执行有个比较清晰的了解，整个过程大致是：监听tcp端口(listen)——>接受连接(accept)——>开启协程处理，下面附上我仔细看了下的源码：
1）net\http\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) //进行处理，并返回数据
}
上面这段基本都看得懂，下面看下真正的处理函数；
2）net\http\server.go
//从监听器上接受即将到来的连接，针对每个连接都会创建一个goroutine去处理
// goroutine会读取请求然后调用handler处理并返回结果
// 当监听器返回的是*tls.Conn的时候才支持HTTP/2，tls是加密连接
func (srv *Server) Serve(l net.Listener) error {
...
....
var tempDelay time.Duration // how long to sleep on accept failure
ctx := context.WithValue(baseCtx, ServerContextKey, srv)
for {
rw, err := l.Accept()
if err != nil {
select {
case <-srv.getDoneChan():
return ErrServerClosed
default:
}
if ne, ok := err.(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", err, tempDelay)
time.Sleep(tempDelay)
continue
}
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, runHooks) // before Serve can return
go c.serve(connCtx) //开启协程调用方法
}
}
- net\http\server.go
// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
...
...
for {
w, err := c.readRequest(ctx) //循环读取请求
...
...
// HTTP cannot have multiple simultaneous active requests.[*]
// Until the server replies to this request, it can't read another,
// so we might as well run the handler in this goroutine.
// [*] Not strictly true: HTTP pipelining. We could let them all process
// in parallel even if their responses need to be serialized.
// But we're not going to implement HTTP pipelining because it
// was never deployed in the wild and the answer is HTTP/2.
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, runHooks)
c.curReq.Store((*response)(nil))
...
...
}
}
下面重点看下serverHandler{c.server}.ServeHTTP(w, w.req) 这行代码里面做的事情
4）net\http\server.go
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
....
....
....
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
handler := sh.srv.Handler //获取Handler
if handler == nil {
handler = DefaultServeMux
}
if req.RequestURI == "*" && req.Method == "OPTIONS" {
handler = globalOptionsHandler{}
}
if req.URL != nil && strings.Contains(req.URL.RawQuery, ";") {
var allowQuerySemicolonsInUse int32
req = req.WithContext(context.WithValue(req.Context(), silenceSemWarnContextKey, func() {
atomic.StoreInt32(&allowQuerySemicolonsInUse, 1)
}))
defer func() {
if atomic.LoadInt32(&allowQuerySemicolonsInUse) == 0 {
sh.srv.logf("http: URL query contains semicolon, which is no longer a supported separator; parts of the query may be stripped when parsed; see golang.org/issue/25192")
}
}()
}
handler.ServeHTTP(rw, req) //处理请求
}
从上面这段代码可以看出ServeHTTP函数最终会调用handler.ServeHTTP()方法，但是handler在不为空或者请求的URI不是*号和请求的方法不是OPTIONS的情况下实际是一个接口类型，接口里面包含了ServeHTTP这个方法，也就是说这个方法的调用实际是和传入的handler参数有关，是由参入参数来实现这个方法的，于是我们需要找到路由注册的地方，也就是初始化服务传入的Handler类型，找到了对应的ServeHTTP方法
5） gin.go
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
c := engine.pool.Get().(*Context) //从对象池里面拿到一个对象，并断言为Context指针类型变量
c.writermem.reset(w)
c.Request = req // 当前请求写入到context 对象中
c.reset()
engine.handleHTTPRequest(c) // 处理请求
engine.pool.Put(c)
}
6）gin.go
func (engine *Engine) handleHTTPRequest(c *Context) {
...
...
// Find root of the tree for the given HTTP method
t := engine.trees
for i, tl := 0, len(t); i < tl; i++ {
if t[i].method != httpMethod {
continue
}
root := t[i].root
// Find route in tree
value := root.getValue(rPath, c.params, unescape) //根据指定的路径找到注册的路由方法
if value.params != nil {
c.Params = *value.params
}
if value.handlers != nil {
c.handlers = value.handlers
c.fullPath = value.fullPath
c.Next() //执行调用
c.writermem.WriteHeaderNow()
return
}
if httpMethod != "CONNECT" && rPath != "/" {
if value.tsr && engine.RedirectTrailingSlash {
redirectTrailingSlash(c)
return
}
if engine.RedirectFixedPath && redirectFixedPath(c, root, engine.RedirectFixedPath) {
return
}
}
break
}
...
...
}
从上面一段代码可以看出如果当前可以匹配到处理的方法，便会执行value.handlers这段代码，通过调用c.Next()方法执行指定的处理函数，下面来看下c.Next()方法：
7）[email protected]\context.go
// Next()方法只能在中间件中使用
//在正在被调用的handler 里面执行被挂起的handler, 这是翻译的效果，笔者的理解就是在中间件
//中去执行一个handler，执行完后接着中间件下面的代码继续执行
func (c *Context) Next() {
c.index++
for c.index < int8(len(c.handlers)) {
c.handlers[c.index](c) //执行方法，c参数是被赋值了当前请求requst的相关信息
c.index++
}
}
到此，我们就解释了文章开头的第一个问题，这里笔者没有对这些代码做详细的分析，就大致看下整个流程。好了下面再来看第二个问题，取数据；
取数据很容易，大致的流程是调用把请求体req.Body解析到指定的对象中，最终解析的代码如下：
func decodeJSON(r io.Reader, obj interface{}) error {
decoder := json.NewDecoder(r)
if EnableDecoderUseNumber {
decoder.UseNumber() //防止数据被转换成float64
}
if EnableDecoderDisallowUnknownFields {
decoder.DisallowUnknownFields() //如果目标结构体中不包含传入的某个字段则会返回一个错误
}
if err := decoder.Decode(obj); err != nil {
return err
}
return validate(obj)
}
具体是如何解析的这篇文章就不详细解释了，后面笔者会出一篇文章详细解释下decode操作。