08-3-Gin框架 - 08-3-1-Gin框架快速入门 - 《GoLang》

1. Gin简单入门

1. Gin简单入门

Gin 框架现在是 github 上 start 最多 Go 语言编写的 Web 框架，相比其他它的几个 start 数量差不多的框架，它更加的轻量，有更好的性能。它使用了httprouter，如果你是性能和高效的追求者, 你会爱上Gin！

1.1. 简单示例

1.1.1. 第一个gin程序

import (
    "github.com/gin-gonic/gin"
    log "github.com/sirupsen/logrus"
)
func main() {
    r := gin.Default()  // 创建默认路由引擎
    // 配置 location 为 / 时，且请求为GET时的路由处理函数
    r.GET("/", func(c *gin.Context) {
        // c.JSON() 构造json格式的响应体，在后端应用中非常常见
        // 请求和响应的响应信息都封装在了对象 c 中
        c.JSON(200, gin.H{
            "method" : c.Request.Method,
            "location": c.Request.URL.String(),
            "message": "Hello world!",
        })
    })
    err := r.Run("0.0.0.0:8080")  // 绑定 8080 端口
    if err != nil {
        log.Fatal("Init gin server failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl 127.0.0.1:8080
{"location":"/","message":"Hello world!","method":"GET"}

1.1.2. RestFul API

在后端开发中，RestFul API 非常常见，即location就是目标资源，而不同的请求方法代表对这个请求资源的操作方式，如：

请求方法	URL	含义
GET	/book/ISBN6379	查询书籍信息
HEADA	/book/ISBN6379	查询书籍是否存在
POST	/book/ISBN6379	创建书籍记录
PUT	/book/ISBN6379	更新书籍信息
DELETE	/book/ISBN6379	删除书籍信息

import (
    "github.com/gin-gonic/gin"
    log "github.com/sirupsen/logrus"
)
func main()  {
    r := gin.Default()
    // GET
    r.GET("/book/ISBN6379", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "method": c.Request.Method,
        })
    })
    // POST
    r.POST("/book/ISBN6379", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "method": c.Request.Method,
        })
    })
    // PUT
    r.PUT("/book/ISBN6379", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "method": c.Request.Method,
        })
    })
    // DELETE
    r.DELETE("/book/ISBN6379", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "method": c.Request.Method,
        })
    })
    if err := r.Run("0.0.0.0:8080"); err != nil {
        log.Fatal("Init web failed, err:%s\n", err.Error())
    }
}

[root@duduniao ~]# for i in GET POST PUT DELETE;do curl -X $i http://127.0.0.1:8080/book/ISBN6379;echo ;done
{"method":"GET"}
{"method":"POST"}
{"method":"PUT"}
{"method":"DELETE"}

1.2. Gin渲染

所谓渲染即生成响应体，在后端开发中，常用的响应体有 json，html，protobuf，静态文件等。

1.2.1. Json 渲染

func main() {
    r := gin.Default()
    // 使用 gin.H{} 构造json
    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "method":   c.Request.Method,
            "location": c.Request.URL.String(),
            "message":  "root page",
        })
    })
    // 使用结构体
    r.GET("/index", func(c *gin.Context) {
        res := struct {
            Method   string `json:"method"`
            Location string `json:"location"`
            Message  string `json:"message"`
        }{c.Request.Method, c.Request.URL.Path, "index page"}
        c.JSON(200, &res)
    })
    err := r.Run("0.0.0.0:8080")
    if err != nil {
        log.Fatal("Init gin server failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl http://127.0.0.1:8080
{"location":"/","message":"root page","method":"GET"}
[root@duduniao ~]# curl http://127.0.0.1:8080/index
{"method":"GET","location":"/index","message":"index page"}

1.2.2. YAML渲染

func main() {
    r := gin.Default()
    // 使用 gin.H{} 构造json
    r.GET("/", func(c *gin.Context) {
        c.YAML(200, gin.H{
            "method":   c.Request.Method,
            "location": c.Request.URL.String(),
            "message":  "root page",
        })
    })
    // 使用结构体
    r.GET("/index", func(c *gin.Context) {
        res := struct {
            Method   string
            Location string
            Message  string
        }{c.Request.Method, c.Request.URL.Path, "index page"}
        c.YAML(200, &res)
    })
    err := r.Run("0.0.0.0:8080")
    if err != nil {
        log.Fatal("Init gin server failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl http://127.0.0.1:8080/index
method: GET
location: /index
message: index page
[root@duduniao ~]# curl http://127.0.0.1:8080
location: /
message: root page
method: GET

1.2.3. XML渲染

与json和yaml返回不同，XML不支持返回匿名结构体对象

func main() {
    r := gin.Default()
    // 使用 gin.H{} 构造json
    r.GET("/", func(c *gin.Context) {
        c.XML(200, gin.H{
            "method":   c.Request.Method,
            "location": c.Request.URL.String(),
            "message":  "root page",
        })
    })
    // 使用结构体
    r.GET("/index", func(c *gin.Context) {
        // 使用匿名结构体会无法显示
        type msg struct {
            Method   string
            Location string
            Message  string
        }
        var res = msg{c.Request.Method, c.Request.URL.Path, "index page"}
        c.XML(200, &res)
    })
    err := r.Run("0.0.0.0:8080")
    if err != nil {
        log.Fatal("Init gin server failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl http://127.0.0.1:8080/index
<msg><Method>GET</Method><Location>/index</Location><Message>index page</Message></msg>
[root@duduniao ~]# curl http://127.0.0.1:8080
<map><method>GET</method><location>/</location><message>root page</message></map>

1.2.4. HTML渲染

在做web开发时，返回渲染的 html 页面常见很常见，一般流程：在 templates 目录下创建html模板文件 —> 导入html模板文件 —> 执行 c.HTML()渲染

[root@duduniao gin_basic]# tree
.
├── html.go
└── templates
    ├── book
    │   └── index.html
    └── user
        └── index.html

{{define "user/index.html"}}
<!DOCTYPE html>
<html lang="en">
<body>
<h1>{{.name}}</h1>
<h1>{{.age}}</h1>
</body>
</html>
{{end}}

{{define "book/index.html"}}
<!DOCTYPE html>
<html lang="en">
<body>
<h2>{{.title}}</h2>
</body>
</html>
{{end}}

package main
import (
    "github.com/gin-gonic/gin"
    log "github.com/sirupsen/logrus"
)
func main() {
    r := gin.Default()
    r.LoadHTMLGlob("templates/**/*.html")
    r.GET("/book/", func(c *gin.Context) {
        c.HTML(200, "book/index.html", gin.H{"title": "books"})
    })
    r.GET("/user/", func(c *gin.Context) {
        c.HTML(200, "user/index.html", gin.H{"name":"张三", "age":18})
    })
    err := r.Run("0.0.0.0:8080")
    if err != nil {
        log.Fatal("Init gin server failed,err:%s", err.Error())
    }
}

1.3. 请求处理

1.3.1. PATH参数处理

所谓PATH参数解析，就是指解析URL的locaction，如从请求 GET /student/201909011208 获取学生的ID 201909011208。PATH中关键词解析是通过占位符来实现的。

func main()  {
    r := gin.Default()
    r.GET("/user/search/:name/:age", func(c *gin.Context) {
        name, age := c.Param("name"), c.Param("age")
        c.JSON(200, gin.H{
            "name": name,
            "age": age,
        })
    })
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatal("Init web failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl http://127.0.0.1/user/search/zhangsan/20
{"age":"20","name":"zhangsan"}
[root@duduniao ~]# curl http://127.0.0.1/user/search/张三/20
{"age":"20","name":"张三"}

1.3.2. GET请求参数

在非 RESTAPI 请求中，请求基本都是通过GET加URL参数完成的，比如 GET /user/search?name=zhangsan&age=20 ，因此对请求URL中的参数解析场景很常见，Gin中采用 c.Query(key) 和 c.DefaultQuery(key,default) 获取，如果对于的key不存在，前者返回空字符串，后者范围指定的default。

func main() {
    r := gin.Default()
    r.GET("/user/search", func(c *gin.Context) {
        name := c.Query("name")
        age := c.Query("age")
        class := c.DefaultQuery("class", "101") // 如果不存在则使用默认值
        c.JSON(200, gin.H{
            "name":  name,
            "age":   age,
            "class": class,
        })
    })
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatal("Init web failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl "http://127.0.0.1/user/search?name=zhangsan&age=20"
{"age":"20","class":"101","name":"zhangsan"}
[root@duduniao ~]# curl "http://127.0.0.1/user/search?name=zhangsan"
{"age":"","class":"101","name":"zhangsan"}

1.3.3. 获取表单参数

在网站中开发中，用户提交注册或者登陆信息一般通过POST表单进行传递，Gin中获取该参数的值是通过 c.PostForm(key) 实现。

func main() {
    r := gin.Default()
    r.POST("/user/search", func(c *gin.Context) {
        name := c.PostForm("name")
        age := c.PostForm("age")
        class := c.PostForm("class")
        c.JSON(200, gin.H{
            "name":  name,
            "age":   age,
            "class": class,
        })
    })
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatal("Init web failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl -X POST "http://127.0.0.1/user/search" -d "name=zhangsan&age=19"
{"age":"19","class":"","name":"zhangsan"}
[root@duduniao ~]# curl -X POST "http://127.0.0.1/user/search" -d "name=zhangsan&age=19&class=301"
{"age":"19","class":"301","name":"zhangsan"}

1.3.4. 获取json参数

获取GET请求参数和表单参数有快捷方式，如上面两个案例所示，但是json类的请求体需要使用 c.BindJson(&obj) 来取参数。

func main() {
    r := gin.Default()
    r.POST("/user/search", func(c *gin.Context) {
        var user UserInfo
        err := c.BindJSON(&user)  // 绑定json解析，query，yaml，xml同理
        if err != nil {
            log.Errorf("Get args failed, err:%s\n", err.Error())
            c.JSON(200, gin.H{"err": err.Error()})
            return
        }
        c.JSON(200, gin.H{
            "name":  user.Name,
            "age":   user.Age,
            "class": user.Class,
        })
    })
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatal("Init web failed,err:", err.Error())
    }
}

[root@duduniao ~]# curl -X POST -H "Content-Type:application/json" -d '{"name":"zhangsan","age":20}' http://127.0.0.1/user/search
{"age":20,"class":"","name":"zhangsan"}
[root@duduniao ~]# curl -X POST -H "Content-Type:application/json" -d '{"name":"zhangsan","age":20,"class":"312"}' http://127.0.0.1/user/search
{"age":20,"class":"312","name":"zhangsan"}

1.3.5. 参数自动绑定

上面的案例中，都是明确知道是URL传参，或者POST表单，或者Json请求体。但是Gin中还提供了一种自动判断参数类型，并解析到结构体对象中的方法。可以自动根据请求类型、Content-Type 来判断请求数据的类型，解析后绑定到指定的结构体中。需要注意的是，结构体中必须打上 form 的tag，否则GET请求中的参数无法解析成功

type UserInfo struct {
    Name  string `form:"name" json:"name"`
    Age   uint8  `form:"age" json:"age"`
    Class string `form:"class" json:"class"`
}
func search(c *gin.Context) {
    var user UserInfo
    err := c.ShouldBind(&user) // 根据 Content-Type 自动进行解析
    if err != nil {
        log.Errorf("Get args failed, err:%s\n", err.Error())
        c.JSON(200, gin.H{"err": err.Error()})
        return
    }
    c.JSON(200, gin.H{
        "method": c.Request.Method,
        "name":   user.Name,
        "age":    user.Age,
        "class":  user.Class,
    })
}
func main() {
    r := gin.Default()
    r.POST("/user/search", search)
    r.GET("/user/search", search)
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatal("Init web failed,err:", err.Error())
    }
}

[root@duduniao ~]# curl "http://127.0.0.1/user/search?name=zhangsan&age=20&class=301"
{"age":20,"class":"301","method":"GET","name":"zhangsan"}
[root@duduniao ~]# curl -X POST "http://127.0.0.1/user/search" -d "name=zhangsan&age=19&class=301"
{"age":19,"class":"301","method":"POST","name":"zhangsan"}
[root@duduniao ~]# curl -X POST -H "Content-Type:application/json" -d '{"name":"zhangsan","age":20,"class":"312"}' http://127.0.0.1/user/search
{"age":20,"class":"312","method":"POST","name":"zhangsan"}

1.4. 上传的文件处理

1.4.1. 上传单个文件

func main() {
    r := gin.Default()
    r.POST("/upload/", func(c *gin.Context) {
        file, err := c.FormFile("background")  // 上传单个文件，明确知晓文件的 key 
        if err != nil {
            c.JSON(400, gin.H{"status": 411, "msg": "recv file failed,err" + err.Error()})
            log.Errorf("recv file failed,err:%s\n", err.Error())
            return
        }
        if err := c.SaveUploadedFile(file, file.Filename); err != nil {
            c.JSON(400, gin.H{"status": 412, "msg": "save file failed, err" + err.Error()})
            log.Errorf("save %s failed,err:%s\n", file.Filename, err.Error())
            return
        }
        log.Infof("recv %s success\n", file.Filename)
        c.JSON(200, gin.H{"status": 200, "msg": "revc success"})
    })
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatal("Init web failed,err:", err.Error())
    }
}

[root@duduniao 壁纸]# curl -X POST -F 'background=@2020-03-14_22-40-07.jpg'  http://127.0.0.1/upload/
{"msg":"revc success","status":200}

1.4.2. 上传多个文件

func main() {
    r := gin.Default()
    // 设置能接收的缓冲区大小
    r.MaxMultipartMemory = 50 * 1024 * 1024
    r.POST("/upload/", func(c *gin.Context) {
        form, err := c.MultipartForm() // 获取表单信息
        if err != nil {
            c.JSON(400, gin.H{"status":411,"msg": "recv file failed, err:" + err.Error()})
            log.Errorf("get files failed,err:%s\n",err.Error())
            return
        }
        files, ok := form.File["files"]  // 获取表单中的文件列表
        if !ok {
            c.JSON(400, gin.H{"status":412,"msg":"recv file failed, err: no key names files"})
            log.Errorf("get files failed,err:%s\n","no key names files")
            return
        }
        // 变量文件对象并写入本地
        for index, file := range files {
            if err := c.SaveUploadedFile(file, fmt.Sprintf("%d-%s", index, file.Filename)); err != nil {
                c.JSON(400, gin.H{"status":412,"msg":"save file failed, err:" + err.Error()})
                log.Errorf("save %s failed,err:%s\n",file.Filename, err.Error())
                return
            }
            log.Infof("save %s success\n",file.Filename)
        }
        log.Infof("recv %s success\n", "file.Filename")
        c.JSON(200, gin.H{"status":200,"msg":"revc success"})
    })
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatal("Init web failed,err:", err.Error())
    }
}

[root@duduniao 壁纸]# curl -X POST -F 'files=@2020-03-10_10-06-06.jpg' -F 'files=@2020-03-10_10-09-32.jpg' -F 'files=@2020-03-14_22-41-02.jpg'  http://127.0.0.1/upload/
{"msg":"revc success","status":200}

1.5. 重定向

在HTTP协议中，重定向分为两种: 301 永久重定向，302 临时重定向。在Gin中，重定向有两种实现的方式，一种是是通过HTTP重定向，指定返回码(301,302)和目标地址即可；另一种是通过修改路由实现，内部进行URL跳转，类似于nginx的rewrite规则。

1.5.1. HTTP重定向

func main() {
    r := gin.Default()
    r.GET("/book/", func(c *gin.Context) {
        // c.Redirect(301, "/books/")  // 永久重定向
        c.Redirect(302, "/books/")  // 临时重定向
    })
    r.GET("/books/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "method" : c.Request.Method,
            "location": c.Request.URL.String(),
            "message": "Hello world!",
        })
    })
    err := r.Run("0.0.0.0:8080")
    if err != nil {
        log.Fatal("Init gin server failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl -Lv http://127.0.0.1:8080/book/
......
> GET /book/ HTTP/1.1
> Host: 127.0.0.1:8080
> User-Agent: curl/7.58.0
> Accept: */*
>
< HTTP/1.1 302 Found
< Content-Type: text/html; charset=utf-8
< Location: /books/
< Date: Sat, 13 Jun 2020 13:52:54 GMT
< Content-Length: 30
<
......
> GET /books/ HTTP/1.1
> Host: 127.0.0.1:8080
> User-Agent: curl/7.58.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Content-Type: application/json; charset=utf-8
< Date: Sat, 13 Jun 2020 13:52:54 GMT
< Content-Length: 62
<
* Connection #0 to host 127.0.0.1 left intact
{"location":"/books/","message":"Hello world!","method":"GET"}

1.5.2. 路由重定向

func main() {
    r := gin.Default()
    r.GET("/book/", func(c *gin.Context) {
        c.Request.URL.Path = "/books/"
        r.HandleContext(c)
    })
    r.GET("/books/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "method" : c.Request.Method,
            "location": c.Request.URL.String(),
            "message": "Hello world!",
        })
    })
    err := r.Run("0.0.0.0:8080")
    if err != nil {
        log.Fatal("Init gin server failed,err:%s", err.Error())
    }
}

[root@duduniao ~]# curl -Lv http://127.0.0.1:8080/book/
*   Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0)
> GET /book/ HTTP/1.1
> Host: 127.0.0.1:8080
> User-Agent: curl/7.58.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Content-Type: application/json; charset=utf-8
< Date: Sat, 13 Jun 2020 13:57:18 GMT
< Content-Length: 62
<
* Connection #0 to host 127.0.0.1 left intact
{"location":"/books/","message":"Hello world!","method":"GET"}

1.6. Gin路由

路由就是请求(请求方法+URL)和处理函数之间的关系绑定，根据业务场景，可以分为普通路由和路由组，普通路由就是一个一个零散的路由，路由组是若干个有关联关系的路由组成，比如对同一个URL的不同方法，同一个API版本的所有路由集合等，路由组习惯性一对{}包裹同组的路由，这只是为了看着清晰，你用不用{}包裹功能上没什么区别。

1.6.1. 普通路由

r.GET("/index", func(c *gin.Context) {...})
r.PUT("/index", func(c *gin.Context) {...})
r.POST("/index", func(c *gin.Context) {...})
r.Any("/index", func(c *gin.Context) {...})  // 匹配任意方法
r.NoRoute(func(c *gin.Context) {...})        // 没有任何匹配项

1.6.2. 路由组

userGroup := r.Group("/user")
{
    userGroup.GET("/index", func(c *gin.Context) {...})
    userGroup.GET("/login", func(c *gin.Context) {...})
    userGroup.POST("/login", func(c *gin.Context) {...})
}
shopGroup := r.Group("/shop")
{
    shopGroup.GET("/index", func(c *gin.Context) {...})
    shopGroup.GET("/cart", func(c *gin.Context) {...})
    shopGroup.POST("/checkout", func(c *gin.Context) {...})
}

1.7. 中间件

Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（Hook）函数。这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等。

1.7.1. 定义中间件

Gin中的中间件必须是一个gin.HandlerFunc类型的函数，因此定义中间件就是定义返回值为 gin.HandlerFunc 的函数。中间件类似于一个装饰器，其中 c.Next() 表示执行被装饰的函数，即路由处理函数。

func timer() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next()  // 执行
        log.Infof("The request [%s %s] const %v\n", c.Request.Method, c.Request.URL.Path, time.Since(start))
    }
}

1.7.2. 注册中间件

中间件的注册分为三种类型：

注册全局中间件，即所有的请求都会调用该中间件进行装饰： r.Use(timer())
为某个特定路由注册，支持多个中间件： r.GET("/", timer(), func(c *gin.context) {} )
为路由组注册中间件，可以在定义路由组的时候注册： userGroup := r.Group("/user", timer2())

也可以对定义好的路由组添加中间件： deployGroup.Use(timer2())
全局中间件和路由中间件，执行顺序，参考一下案例：

import (
    "fmt"
    "github.com/gin-gonic/gin"
    log "github.com/sirupsen/logrus"
    "time"
)
func response(c *gin.Context) {
    time.Sleep(time.Millisecond * 100)
    c.JSON(200, gin.H{"message": "ok", "location": c.Request.URL.String()})
}
func timer1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("timer1 start")
        start := time.Now()
        c.Next()
        log.Infof("[timer1] The request [%s %s] const %v\n", c.Request.Method, c.Request.URL.Path, time.Since(start))
        fmt.Println("timer1 stop")
    }
}
func timer2() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("timer2 start")
        start := time.Now()
        c.Next()
        log.Infof("[timer2] The request [%s %s] const %v\n", c.Request.Method, c.Request.URL.Path, time.Since(start))
        fmt.Println("timer2 stop")
    }
}
func main() {
    r := gin.Default()
    r.Use(timer1()) // 注册全局中间件
    r.GET("/index", timer2(), response) // 为特定路由注册中间件
    userGroup := r.Group("/user", timer2()) // 为路由组添加中间件
    {
        userGroup.GET("/index", response)
        userGroup.GET("/edit", response)
    }
    deployGroup := r.Group("/deploy")
    deployGroup.Use(timer2()) // 为路由组添加中间件
    {
        deployGroup.GET("/deployment", response)
        deployGroup.GET("/service", response)
        deployGroup.GET("/template", response)
    }
    if err := r.Run("0.0.0.0:80"); err != nil {
        log.Fatalf("Init gin failed, err:%s\n", err.Error())
    }
}

[root@duduniao ~]# curl http://127.0.0.1/index
{"location":"/index","message":"ok"}
------
timer1 start
timer2 start
INFO[0009] [timer2] The request [GET /index] const 100.7118ms
timer2 stop
INFO[0009] [timer1] The request [GET /index] const 100.8172ms
timer1 stop
[root@duduniao ~]# curl http://127.0.0.1/user/edit
{"location":"/user/edit","message":"ok"}
------
timer1 start
timer2 start
INFO[0018] [timer2] The request [GET /user/edit] const 100.5929ms
timer2 stop
INFO[0018] [timer1] The request [GET /user/edit] const 100.6653ms
timer1 stop
[root@duduniao ~]# curl http://127.0.0.1/deploy/service
{"location":"/deploy/service","message":"ok"}
------
timer1 start
timer2 start
INFO[0026] [timer2] The request [GET /deploy/service] const 100.3718ms
timer2 stop
INFO[0026] [timer1] The request [GET /deploy/service] const 100.4596ms
timer1 stop

1.7.3. 中间件注意事项

gin默认中间件

gin.Default()默认使用了Logger和Recovery中间件，其中：

Logger中间件将日志写入gin.DefaultWriter，即使配置了GIN_MODE=release。
Recovery中间件会recover任何panic。如果有panic的话，会写入500响应码。

如果不想使用上面两个默认的中间件，可以使用gin.New()新建一个没有任何默认中间件的路由。

gin中间件中使用goroutine

当在中间件或handler中启动新的goroutine时，不能使用原始的上下文（c *gin.Context），必须使用其只读副本（c.Copy()）