前言
gin框架是go语言的一个框架，框架的github地址是：https://github.com/gin-gonic/gin
转载本文，请标注原文地址：https://www.cnblogs.com/-beyond/p/9391892.html
安装gin框架
go get -u github.com/gin-gonic/gin
第一次使用gin框架
创建一个文件main.go，拷贝如下内容
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
router.GET("/get", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "use get method"})
})
router.Run()
}使用 go run main.go 运行程序，程序默认绑定的是8080端口，测试使用浏览器访问localhost:8080/get，会有如下response：
切换绑定端口
gin框架默认的是绑定到8080端口，但是可以切换端口，方法就是指定router.Run()的参数。
router.Run()的声明如下：
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
}可以看到，Run方法也只是使用了http的ListenAndServe方法而已
现在可以将端口绑定到9000端口，可以这样写：
router.Run(":9000")
gin.H{ }
第1个代码例子中，有这么一行c.JSON(200, gin.H{"message": "use get method"})
这其中有一个gin.H{ }，看样子，这像是一个结构体struct，查看gin框架的源码，声明如下：
// H is a shortcut for map[string]interface{}
type H map[string]interface{}所以，这只是一个map结构，别以为是一个struct哈
设置http请求方式
gin框架封装了http库，提供了GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS这些http请求方式。
使用router.method()来绑定路由
声明如下:
func (group *RouterGroup) METHOD(relativePath string, handlers ...HandlerFunc) IRoutes其中的METHOD可以是上面的7种方式。
例子：
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
router.GET("/get", func(c *gin.Context) { c.JSON(200, gin.H{"message": "use get method"}) })
router.POST("/post", func(c *gin.Context) { c.JSON(200, gin.H{"message": "use post method"}) })
router.PUT("/put", func(c *gin.Context) { c.JSON(200, gin.H{"message": "use put method"}) })
router.DELETE("/delete", func(c *gin.Context) { c.JSON(200, gin.H{"message": "use delete method"}) })
router.PATCH("/patch", func(c *gin.Context) { c.JSON(200, gin.H{"message": "use patch method"}) })
router.HEAD("/head", func(c *gin.Context) { c.JSON(200, gin.H{"message": "use head method"}) })
router.OPTIONS("/options", func(c *gin.Context) { c.JSON(200, gin.H{"message": "use options method"}) })
router.Run()
}使用对应的method访问对应的path，会的对应的response。
但是如果使用不对应的method访问path，就会返回404，比如使用post方法访问localhost:8080/get会返回404。
切换输出的格式
看下面的代码：
router.GET("/get", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "use get method"})
})上面的这段代码，就是在用户访问localhost:8080时，c.JSON()返回一个响应，响应中的状态码是200，响应内容是一个JSON格式的字符串。
那么我们就很容易知道，不同的响应内容格式是通过调用*gin.Context类型变量的不同方法来实现的。
gin框架提供了很多响应内容的格式，常用的方法声明如下：
//返回json格式
func (c *Context) JSON(code int, obj interface{})
//返回xml格式
func (c *Context) XML(code int, obj interface{})
//返回yaml格式
func (c *Context) YAML(code int, obj interface{})
//返回string格式
func (c *Context) String(code int, format string, values ...interface{})
//渲染html模板后返回
func (c *Context) HTML(code int, name string, obj interface{})示例：
package main
import (
"fmt"
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
router.GET("/json", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "return json data"})
})
router.GET("/string", func(c *gin.Context) {
c.String(200, "message %s", "return string data")
})
router.GET("/yaml", func(c *gin.Context) {
arr := [][]string{
{"one", "two", "three"},
{"four", "five", "six"},
}
c.YAML(200, arr)
})
router.GET("/xml", func(c *gin.Context) {
person := struct { //声明一个匿名结构体
Name string
Age int
}{"Jane", 20}
c.XML(200, fmt.Sprintln(person))
})
router.Run()
}
状态码
注意上面每一个响应中都有一个状态码200。
这个状态码不仅可以手动指定一个数字，比如200，500，404；也可以使用http包中的状态码，语义化的状态码更好理解；
下面解释http协议中所有的状态码了。
package http
// HTTP status codes as registered with IANA.
// See: http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
const (
StatusContinue = 100 // RFC 7231, 6.2.1
StatusSwitchingProtocols = 101 // RFC 7231, 6.2.2
StatusProcessing = 102 // RFC 2518, 10.1
StatusOK = 200 // RFC 7231, 6.3.1
StatusCreated = 201 // RFC 7231, 6.3.2
StatusAccepted = 202 // RFC 7231, 6.3.3
StatusNonAuthoritativeInfo = 203 // RFC 7231, 6.3.4
StatusNoContent = 204 // RFC 7231, 6.3.5
StatusResetContent = 205 // RFC 7231, 6.3.6
StatusPartialContent = 206 // RFC 7233, 4.1
StatusMultiStatus = 207 // RFC 4918, 11.1
StatusAlreadyReported = 208 // RFC 5842, 7.1
StatusIMUsed = 226 // RFC 3229, 10.4.1
StatusMultipleChoices = 300 // RFC 7231, 6.4.1
StatusMovedPermanently = 301 // RFC 7231, 6.4.2
StatusFound = 302 // RFC 7231, 6.4.3
StatusSeeOther = 303 // RFC 7231, 6.4.4
StatusNotModified = 304 // RFC 7232, 4.1
StatusUseProxy = 305 // RFC 7231, 6.4.5
_ = 306 // RFC 7231, 6.4.6 (Unused)
StatusTemporaryRedirect = 307 // RFC 7231, 6.4.7
StatusPermanentRedirect = 308 // RFC 7538, 3
StatusBadRequest = 400 // RFC 7231, 6.5.1
StatusUnauthorized = 401 // RFC 7235, 3.1
StatusPaymentRequired = 402 // RFC 7231, 6.5.2
StatusForbidden = 403 // RFC 7231, 6.5.3
StatusNotFound = 404 // RFC 7231, 6.5.4
StatusMethodNotAllowed = 405 // RFC 7231, 6.5.5
StatusNotAcceptable = 406 // RFC 7231, 6.5.6
StatusProxyAuthRequired = 407 // RFC 7235, 3.2
StatusRequestTimeout = 408 // RFC 7231, 6.5.7
StatusConflict = 409 // RFC 7231, 6.5.8
StatusGone = 410 // RFC 7231, 6.5.9
StatusLengthRequired = 411 // RFC 7231, 6.5.10
StatusPreconditionFailed = 412 // RFC 7232, 4.2
StatusRequestEntityTooLarge = 413 // RFC 7231, 6.5.11
StatusRequestURITooLong = 414 // RFC 7231, 6.5.12
StatusUnsupportedMediaType = 415 // RFC 7231, 6.5.13
StatusRequestedRangeNotSatisfiable = 416 // RFC 7233, 4.4
StatusExpectationFailed = 417 // RFC 7231, 6.5.14
StatusTeapot = 418 // RFC 7168, 2.3.3
StatusUnprocessableEntity = 422 // RFC 4918, 11.2
StatusLocked = 423 // RFC 4918, 11.3
StatusFailedDependency = 424 // RFC 4918, 11.4
StatusUpgradeRequired = 426 // RFC 7231, 6.5.15
StatusPreconditionRequired = 428 // RFC 6585, 3
StatusTooManyRequests = 429 // RFC 6585, 4
StatusRequestHeaderFieldsTooLarge = 431 // RFC 6585, 5
StatusUnavailableForLegalReasons = 451 // RFC 7725, 3
StatusInternalServerError = 500 // RFC 7231, 6.6.1
StatusNotImplemented = 501 // RFC 7231, 6.6.2
StatusBadGateway = 502 // RFC 7231, 6.6.3
StatusServiceUnavailable = 503 // RFC 7231, 6.6.4
StatusGatewayTimeout = 504 // RFC 7231, 6.6.5
StatusHTTPVersionNotSupported = 505 // RFC 7231, 6.6.6
StatusVariantAlsoNegotiates = 506 // RFC 2295, 8.1
StatusInsufficientStorage = 507 // RFC 4918, 11.5
StatusLoopDetected = 508 // RFC 5842, 7.2
StatusNotExtended = 510 // RFC 2774, 7
StatusNetworkAuthenticationRequired = 511 // RFC 6585, 6
)测试，在使用的时候，直接作为上面响应中的参数即可。
router.GET("/json", func(c *gin.Context) {
c.JSON(http.StatusNotFound, gin.H{"message": "not found"})
//等价于
//c.JSON(404, gin.H{"message": "not found"})
})
绑定路由
gin框架和使用原生http库绑定路由的形式很相似，但是呢，go语言支持在路由中使用类似于正则表达式的路由，注意这里是类似于正则表达式，因为这里有一定的规则。
获取URL中的路径参数
比如：http://localhost:8080/user/jane/20/beijing/female?id=999&height=170&wigth=100
上面的这个链接中，可以通过向上面讲的使用/user/:name/:age/:addr/:sex来分别匹配jane、20、beijing、female。
获取URL的所有路径参数
gin框架中如果使用URL传递参数，那么在绑定的时候，是这样的：
/user/:name/:age/:addr/:sex上面这个path绑定了4个URL参数，分别是name、age、addr、sex
首先gin.Context对象的Params属性保存着URL中的所有参数：
router.GET("/user/:name/:age/:addr/:sex", func(c *gin.Context) {
//打印URL中所有参数
c.JSON(200, fmt.Sprintln(c.Params))
})如果请求http://localhost:8080/user/jane/20/beijing/female
得到的输出如下：
"[{name jane} {age 20} {addr beijing} {sex female}]\n"注意最后面的那个换行符
获取URL中的指定路径参数
使用gin.Context对象的Param(key)方法获取某一个key的值，方法声明如下：
router.GET("/user/:name/:age/:addr/:sex", func(c *gin.Context) {
name := c.Param("name") //获取参数的时候，不要写name前面的冒号:
c.JSON(200, name)
})访问http://localhost:8080/user/jane/20/beijing/female，输出"jane"
获取URL中请求的参数（GET请求）
获取URL中路径值和获取参数不一样。
比如：http://localhost:8080/user/jane/20/beijing/female?id=999&height=170&wight=100
可以使用接下在的方法获取请求参数id、height、weight的值。
获取指定参数的只
使用gin.Context.Query()，
//返回URL中key的值
func (c *Context) Query(key string) string测试：
router.GET("/user/:name/:age/:addr/:sex", func(c *gin.Context) {
id := c.Query("id")
height := c.Query("height")
weight := c.Query("weight")
c.JSON(200, gin.H{"id": id, "height": height, "weight": weight})
})访问http://localhost:8080/user/jane/20/beijing/female?id=999&height=170&wight=100，输出内容如下：
{"height":"170","id":"999","weight":"100"}
获取指定参数的值（带有默认值的接收）
当然，以前写php的时候，如果要想判断是否接收到了某个参数，如果没有接收到，那么就设置一个默认值，最常用的就是三元运算符，比如下面这样：
$id = empty($_POST['id']) ? 0 : $_POST['id'];gin框架当然也想到了这么一点，gin.Context.DefaultQuery()方法，允许你指定接收的参数名，以及没有接收到该参数值时，设置的默认值，声明如下：
func (c *Context) DefaultQuery(key, defaultValue string) string只有当请求没有携带key，那么此时的默认值就会生效。其他情况，默认值不生效。即使URL中的该key的值为空，那么也不会启用默认值，获取的值就是空。
注意，这是获取URL中的参数值。
接收multipart/urlencoded form（POST表单数据）
和获取URL中的参数很相似：
GET请求中的参数使用Query(key)，DefaultQuery(key,default)来获取
POST请求中的参数使用PostForm(key)，DefaultPostForm(key,default)来获取。
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
router.POST("/post", func(c *gin.Context) {
name := c.PostForm("name")
age := c.PostForm("age")
sex := c.DefaultPostForm("sex", "male")
c.JSON(200, gin.H{"name": name, "age": age, "sex": sex})
})
router.Run()
}注意要想获取POST方式传递的参数，那么绑定的路由监听方式就必须是router.POST，不能使router.GET。
同时获取URL中的参数和POST的参数
前提：请求方必须是使用POST方式传递，只不过URL中也包含一部分参数而已。
同时，服务器端必须使用router.POST方式来接收，不能使用router.GET方式接收，因为router.GET只能接收GET方式传递的数据。
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
//注意，这里必须使用router.POST
router.POST("/post", func(c *gin.Context) {
name := c.PostForm("name")
age := c.PostForm("age")
sex := c.DefaultPostForm("sex", "male")
addr := c.Query("addr")
hobby := c.DefaultQuery("hobby", "basketball")
c.JSON(200, gin.H{"name": name, "age": age, "sex": sex, "addr": addr, "hobby": hobby})
})
router.Run()
}请求：localhost:8080/post?addr=beijing&hobby=football
同时使用post方式传递name=abc&age=21111&sex=female
那么得到的响应就是如下内容：
{"addr":"beijing","age":"21111","hobby":"football","name":"abc","sex":"female"}
接收post发送的单个文件
首先需要注意的是：请求方的method必须是post，Content-Type或者表单中要设成multipart/form-data。
服务器端也要使用post方式接收。
使用gin.Context.FormFile("file")来接收上传的文件，声明如下：
func (c *Context) FormFile(name string) (*multipart.FileHeader, error)示例：
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
router.POST("/upload", func(c *gin.Context) {
file, _ := c.FormFile("myfile") //获取文件
filename := file.Filename
size := file.Size
header := file.Header
c.JSON(200, gin.H{
"filename": filename,
"size": size,
"header": header,
})
})
router.Run()
}使用浏览器发送文件：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<form action="http://localhost:8080/upload" method="post" enctype="multipart/form-data">
上传文件：<input type="file" name="myfile"><br>
<input type="submit">
</form>
</body>
</html>发送了一个文件后，获得的响应如下：
{
"filename": "index.html",
"header": {
"Content-Disposition": [
"form-data; name=\"myfile\"; filename=\"index.html\""
],
"Content-Type": [
"text/html"
]
},
"size": 289
}
接收post发送的多个文件
可以按照使用接收单个文件的套路，来处理多个文件。
比如下面这样：
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
router.POST("/upload", func(c *gin.Context) {
file_1, _ := c.FormFile("myfile_1")
file_2, _ := c.FormFile("myfile_2")
file_3, _ := c.FormFile("myfile_3")
c.IndentedJSON(200, gin.H{
"file_1": file_1.Filename,
"file_2": file_2.Filename,
"file_3": file_3.Filename,
})
})
router.Run()
}html代码如下：
<form action="http://localhost:8080/upload" method="post" enctype="multipart/form-data">
上传文件一：<input type="file" name="myfile_1"><br>
上传文件二：<input type="file" name="myfile_2"><br>
上传文件三：<input type="file" name="myfile_3"><br>
<input type="submit">
</form>发送三个文件，获得的相应：
{
"file_1": "fire.png",
"file_2": "index.html",
"file_3": "Unknown.png"
}
一次性接收多个文件
前面这种方法虽然能接收很多文件，但是，每一个文件都要有单独的name，这就存在一个问题，如果上传的文件有成百上千个，那么就有的忙了。
这里就可以使用gin框架封装的另外一个接口
组路由
什么叫组路由？为什么要使用组路由？优点？
首先看下面这段代码：
func main() {
router := gin.Default()
router.GET("/v1/demo", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v1/demo"})
})
router.GET("/v1/test", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v1/test"})
})
router.GET("/v2/demo", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v2/demo"})
})
router.GET("/v2/test", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v2/test"})
})
router.Run()
}这段代码一点毛病都没有，运行也很正常，但是，有个问题，如果v1，v2是API的版本，那么上面这样写，是不是不太直观呀，如果几百个接口都有v1和v2两个版本，那这个文件的可读性太差了。
所以，组路由就派上大用场了。
上面的程序可以改写下面这样：
func main() {
router := gin.Default()
v1 := router.Group("/v1")
{
v1.GET("/demo", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v1/demo"})
})
v1.GET("/test", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v1/test"})
})
}
v2 := router.Group("v2")
{
v2.GET("/demo", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v2/demo"})
})
v2.GET("/test", func(c *gin.Context) {
c.JSON(200, gin.H{"data": "/v2/test"})
})
}
router.Run()
}照样一点毛病都没有。
使用中间件
之前我们使用的都是router.Default()，其实也是使用了中间件的，比如logger、recover，这是gin框架默认附带的。
指定访问日志文件
这个就是类似于apache的访问日志文件
func main() {
//取消控制台中日志的字体颜色
gin.DisableConsoleColor()
//创建一个日志文件
access_log, _ := os.Create("access_log.log")
gin.DefaultWriter = io.MultiWriter(access_log)
router := gin.Default()
router.GET("/log", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "hello world"})
})
router.Run()
}尝试请求http://localhost:8080/log，然后查看当前目录的access_log.log文件。
请求时间 状态码 请求处理时间 发起请求的IP 发起请求的方法 请求的路径
[GIN] 2018/08/02 - 19:33:28 | 200 | 273.678µs | ::1 | GET /log
绑定post参数到模型中
请看下面的代码，完成一个登录验证功能：
func main() {
router := gin.Default()
router.POST("/login", func(c *gin.Context) {
username := c.PostForm("username")
password := c.PostForm("password")
if username == "abc" && password == "123" {
c.JSON(200, gin.H{"message": "welcome"})
} else {
c.JSON(401, gin.H{"message": "wrong username or password"})
}
})
router.Run(":8080")
}
现在gin框架提供另外一种方式，如下：
type Login struct {
User string `form:"user" json:"user" binding:"required"`
Password string `form:"password" json:"password" binding:"required"`
}
func main() {
router := gin.Default()
router.POST("/loginJSON", func(c *gin.Context) {
var json Login
if err := c.ShouldBindJSON(&json); err == nil {
if json.User == "abc" && json.Password == "123" {
c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
} else {
c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
}
} else {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
}
})
router.POST("/loginForm", func(c *gin.Context) {
var form Login
if err := c.ShouldBind(&form); err == nil {
if form.User == "abc" && form.Password == "123" {
c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
} else {
c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
}
} else {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
}
})
router.Run()
}首先，绑定两个路径分别是loginJSON、loginForm。
对于loginJSON来说，通过gin.Context.ShouldBindJSON(&json)，可以将post方式传递json格式的username和password分别赋值给json这个结构体中的User和Password属性，然后在使用该结构体来完成验证。
比如，请求http://localhost:8080/loginJSON，通过post请求传递了{"user":"abc","password":"123"}，那么就可以通过验证，获得响应结果是：{"status":"you are logged in"}，其他的登录名和密码都不能通过验证。
相对于loginJSON来说，loginForm中使用的gin.Context.ShouldBind(&json)是一样的用法。
绑定GET参数到模型中
从URL中获取参数绑定到模型使用的是gin.ShouldBindQuery(&json)方法，注意此时绑定路由时，使用GET方法
例子：
type Login struct {
User string `form:"user" json:"user" binding:"required"`
Password string `form:"password" json:"password" binding:"required"`
}
func main() {
router := gin.Default()
router.GET("/login", func(c *gin.Context) {
var json Login
if err := c.ShouldBindQuery(&json); err == nil {
if json.User == "abc" && json.Password == "123" {
c.JSON(200, gin.H{"message": "welcome"})
} else {
c.JSON(401, gin.H{"message": "wrong username or password"})
}
} else {
c.JSON(400, gin.H{"error": err.Error()})
}
})
router.Run()
}测试：
请求http://localhost:8080/login?user=abc&password=123，携带了user和password，返回{"message":"welcome"}
gin.HandlerFunc
为什么突然提到这个，因为，我们一直在用它，比如下面的
router.GET("/demo", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "hello world"})
})绑定的func(c *gin.Context){ code } 就是gin.HandlerFunc，这里是一个匿名函数的形式，其实我们完全可以将它提出来，让多个路径共用，比如下面这样：
//声明一个gin.HandlerFunc
func response(c *gin.Context) {
c.JSON(200, gin.H{"message": "hello world"})
}
func main() {
router := gin.Default()
router.GET("/demo", response)
router.GET("/test", response)
router.GET("/aaaa", response)
router.Run()
}上面这个程序执行后，不管是访问demo、test、aaaa都是使用同一个事件处理程序。
从POST或者GET中获取数据绑定到模型
如果了解PHP的话，就知道php接收数据有$_GET、$_POST超全局数组，分别用来接收get请求和get请求传递的参数。同时还有$_REQUEST超全局数组既可以接收get请求和post请求中的参数（这里其实不是$_GET、$_POST、$_REQUEST来接收，而是将接收到的数据存在这些超全局数组里面）。
其实gin框架中虽然没有$REQUEST，但是可以使用下面这个程序替代一下，原理就是上面的多个路由绑定同一个事件处理程序：
type Login struct {
User string `form:"user" json:"user" binding:"required"`
Password string `form:"password" json:"password" binding:"required"`
}
//声明一个gin.HandlerFunc
func LoginCheck(c *gin.Context) {
var json Login
var err error
if err := c.ShouldBindQuery(&json); err == nil { //尝试从get请求中获取参数
if json.User == "abc" && json.Password == "123" {
c.JSON(200, gin.H{"message": "login in success by Get method"})
} else {
c.JSON(200, gin.H{"message": "login in failed by Get method"})
}
} else if err := c.ShouldBind(&json); err == nil { //尝试从post请求中获取参数
if json.User == "abc" && json.Password == "123" {
c.JSON(200, gin.H{"message": "login in success by POST method"})
} else {
c.JSON(200, gin.H{"message": "login in failed by POST method"})
}
}
if err != nil { //解析请求中的参数失败
c.JSON(400, gin.H{"message": err.Error()})
}
}
func main() {
router := gin.Default()
//对于GET和POST，都尝试使用同一个事件处理程序
router.GET("login", LoginCheck)
router.POST("login", LoginCheck)
router.Run()
}
接收checkbox的请求参数，绑定到模型中
接收checkbox数据
前面讲的使用gin.Context.PostForm(key)接收单个post请求中参数key的值，但是如果传递多个同名的参数（checkbox）时，如下：
<form action="http://localhost:8080/upload" method="post" enctype="multipart/form-data">
<input type="checkbox" name="hobby[]" value="swimming">游泳
<input type="checkbox" name="hobby[]" value="basketball">篮球
<input type="checkbox" name="hobby[]" value="football">足球
<input type="submit">
</form>那么使用前面的PostForm(key)只能获取到第一个值swimming。
如果要接受多个hobby，就必须使用gin.Context.PostFormArray("key")来接收即可，向下面这样：
func main() {
router := gin.Default()
router.POST("/checkbox", func (c *gin.Context) {
data := c.PostFormArray("hobby[]") //注意接收的key是一个数组（后面加[]）
c.JSON(200, gin.H{"message": data})
})
router.Run()
}运行测试，全选checkbox，发送post请求后，获得的相应如下：
{
"message": [
"swimming",
"basketball",
"football"
]
}
绑定到模型中
如果要将收到的checkbox数据绑定到模型中，使用gin框架提供的方法，可以向下面这么做：
type CheckBox struct {
//注意如果是checkbox，那么标签中的key要加[]，还有就是属性一定要大写（可见性）
Hobby []string `form:"hobby[]" json:"hobby[]" binding:"required"`
}
func main() {
router := gin.Default()
router.POST("/checkbox", func(c *gin.Context) {
var checkbox CheckBox
if c.ShouldBind(&checkbox) == nil {
c.JSON(200, gin.H{"hobby": checkbox.Hobby})
} else {
c.JSON(400, gin.H{"message": "invalid request params"})
}
})
router.Run()
}很容易忽略的一点就是结构体中的Hobby属性一定要大写，否则因为可见性的规则，小写的hobby是不能进行模型绑定的，访问到的也是一个null值。
返回静态文件
其实在网站访问过程中，有很多的资源都是静态的，也就是说，这些静态资源是可以直接从硬盘上读取之后返回用户，不需要服务器端在做多余的处理。
gin框架中提供了三个方法来实现：
func main() {
router := gin.Default()
//设置静态文件目录，如果访问localhost:8080/assets/test.txt
//如果./assets/test.txt文件存在，那么就返回该文件，否则返回404
router.Static("/assets", "./assets")
//和上面的功能一样
router.StaticFS("/my_file", http.Dir("my_file"))
//为单个文件绑定路由
//可以通过访问localhost:8080/family.pic来获取./pic/family.pic文件
router.StaticFile("/family.pic", "./pic/family.pic")
router.Run()
}注意上面的绑定path，使用的相对路径，不是绝对路径。
来源：oschina
链接：https://my.oschina.net/u/4295884/blog/4532486