Gin笔记

一、环境搭建：

Gin是一个很受欢迎的Go web框架

下载前在Goland最好配置一下代理

 GOPROXY=https://goproxy.cn,direct

在Goland中创建Go项目之后，下载Gin的依赖

 go get -u github.com/gin-gonic/gin

安装postman

修改ip为内网ip

 router.Run("0.0.0.0:8080")

二、响应

响应json：

状态码200等价于http.StatusOk

 package main
 
import "github.com/gin-gonic/gin"
 
func _string(c *gin.Context) {
	c.String(200, "你好呀")
}
 
func _json(c *gin.Context) {
	// json响应结构体
	//type Userinfo struct {
	//	UserName string `json:"user_name"`
	//	Age      int    `json:"age"`
	//	Password string `json:"-"` // 忽略会转换成json
	//}
	//user := Userinfo{
	//	UserName: "百香果",
	//	Age:      23,
	//}
 
	// json响应map
	//userMap := map[string]string{
	//	"username": "草莓",
	//	"age":      "25",
	//}
 
	// 直接响应json
	c.JSON(200, gin.H{"userName": "芒果", "age": "26"})
 
	//c.JSON(200, user)
	//c.JSON(200, userMap)
}
 
func main() {
	router := gin.Default()
	router.GET("/", _string)
	router.GET("/json", _json)
	router.Run(":80")
}

响应xml和yaml：

 // 响应xml
func _xml(c *gin.Context) {
	c.XML(200, gin.H{"userName": "芒果", "age": "26", "status": http.StatusOK, "data": gin.H{"user": "菠萝"}})
}
 
// 响应yaml
func _yaml(c *gin.Context) {
	c.YAML(200, gin.H{"userName": "芒果", "age": "26", "status": http.StatusOK, "data": gin.H{"user": "菠萝"}})
}
 
func main() {
	router := gin.Default()
	router.GET("/xml", _xml)
	router.GET("/yaml", _yaml)
	router.Run(":80")
}

响应html：

 // 响应html
func _html(c *gin.Context) {
	c.HTML(200, "index.html", gin.H{"username": "铃兰"})
}
func main() {
	router := gin.Default()
	router.LoadHTMLGlob("templates/*") // 要把html文件加载进来
	router.GET("/html", _html)
	router.Run(":80")
}

文件响应：

 package main
 
import (
	"github.com/gin-gonic/gin"
	"net/http"
)
 
func _string(c *gin.Context) {
	c.String(200, "你好呀")
}
 
func main() {
	router := gin.Default()
	// 加载模板目录下的所有模板文件
	router.LoadHTMLGlob("templates/*") // 要把html文件加载进来
	// 在go中，没有相对文件的路径，只有相对项目的路径
	// 这样可以做到只拿到static/static下面的文件，static下面的文件不指定无法获取到
	// 网页请求静态目录的前缀，后面是http.Dir方法，是一个目录，注意前缀不要重复
	router.StaticFS("/static", http.Dir("static/static"))
	// 配置单个文件，网页请求的路由，文件的路径
	router.StaticFile("/cat.png", "static/cat.png")
	router.Run(":80")
}

重定向：

 package main
 
import (
	"github.com/gin-gonic/gin"
	"net/http"
)
 
// 重定向
func _redirect(c *gin.Context) {
	// 第一个是重定向的状态码
	//c.Redirect(301, "https://www.baidu.com")
	//c.Redirect(302, "https://www.cnblogs.com/oaoa/")
	//也可以直接写路径
	c.Redirect(302, "/html")
}
 
func main() {
	router := gin.Default()
	// 加载模板目录下的所有模板文件
	router.LoadHTMLGlob("templates/*") // 要把html文件加载进来
	router.GET("/", _string)
	router.GET("/baidu", _redirect)
 
	router.Run(":80")
}

三、请求

查询参数Query：

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
)
 
func _query(c *gin.Context) {
	fmt.Println(c.Query("user"))
	fmt.Println(c.GetQuery("user"))
	fmt.Println(c.QueryArray("user")) // 如果传了多个user，拿到相同的查询参数
    fmt.Println(c.DefaultQuery("addr", "北京")) // 用户没传就使用默认值
}
 
func main() {
	router := gin.Default()
	router.GET("/query", _query)
	router.Run(":80")
}

动态参数Param：

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
)
 
func _query(c *gin.Context) {
	fmt.Println(c.Query("user"))
	fmt.Println(c.GetQuery("user"))
	fmt.Println(c.QueryArray("user")) // 如果传了多个user，拿到相同的查询参数
}
 
func _param(c *gin.Context) {
	fmt.Println(c.Param("user_id")) // 除了路径之外的信息
	fmt.Println(c.Param("book_id"))
	//http://127.0.0.1:80/param/xxxhhh/bookid13
}
 
func main() {
	router := gin.Default()
	router.GET("/query", _query)
	router.GET("/param/:user_id", _param)
	router.GET("/param/:user_id/:book_id", _param)
	router.Run(":80")
}

表单参数PostForm：

可以接收mutipart/form-data和application/x-www-form-urlencoded

 func _form(c *gin.Context) {
	fmt.Println(c.PostForm("name"))
	fmt.Println(c.PostFormArray("name"))
	fmt.Println(c.DefaultPostForm("addr", "北京")) // 如果用户没有传就使用默认值
	forms, err := c.MultipartForm()              // 接收所有的form参数，包括文件
	fmt.Println(forms, err)
}
func main() {
	router := gin.Default()
	router.POST("/form", _form)
	router.Run(":80")
}

补充：

form-data

就是http请求中的multipart/form-data,它会将表单的数据处理为一条消息，以标签为单元，用分隔符分开。既可以上传键值对，也可以上传文件。当上传的字段是文件时，会有Content-Type来表名文件类型；content-disposition，用来说明字段的一些信息；

由于有boundary隔离，所以multipart/form-data既可以上传文件，也可以上传键值对，它采用了键值对的方式，所以可以上传多个文件。

x-www-form-urlencoded

就是application/x-www-from-urlencoded,会将表单内的数据转换为键值对，比如,name=java&age = 23

区别

multipart/form-data：既可以上传文件等二进制数据，也可以上传表单键值对，只是最后会转化为一条信息； x-www-form-urlencoded：只能上传键值对，并且键值对都是间隔分开的。

原始参数GetRawData：

 func _bindJson(c *gin.Context, obj any) (err error) {
	body, _ := c.GetRawData()
	contentType := c.GetHeader("Content-Type")
	fmt.Println(contentType)
	switch contentType {
	case "application/json": // 解析json数据
		err := json.Unmarshal(body, &obj)
		if err != nil {
			fmt.Println(err.Error())
			return err
		}
	}
	return nil
}
 
func _raw(c *gin.Context) {
	type User struct {
		Name string `json:"name"`
		Age  int    `json:"age"`
	}
	var user User
	err := _bindJson(c, &user)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(user)
}
func main() {
	router := gin.Default()
	router.POST("/raw", _raw)
	router.Run(":80")
}

四大请求方式：

Restful风格指的是网络应用中资源定位和资源操作的风格，不是标准也不是协议

GET：从服务器取出资源（一项或多项）

POST：在服务器新建一个资源

PUT：在服务器更新资源（客户端提供完整资源数据）

PATCH：在服务器更新资源（客户端提供需要修改的资源数据）

DELETE：从服务器删除资源

 /* 
以文字资源为例
GET    /articles       文章列表
GET    /articles/:id   文章详情
POST   /articles       添加文章
PUT    /articles/:id   修改某一篇文章
DELETE /articles/:id   删除某一篇文章
*/

 package main
 
import (
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
)
 
type ArticleModel struct {
	Title   string `json:"title"`
	Content string `json:"content"`
}
 
func _bindJson(c *gin.Context, obj any) (err error) {
	body, _ := c.GetRawData()
	contentType := c.GetHeader("Content-Type")
	//fmt.Println(contentType)
	switch contentType {
	case "application/json": // 解析json数据
		err = json.Unmarshal(body, &obj)
		if err != nil {
			fmt.Println(err.Error())
			return err
		}
	}
	return nil
}
 
// 文章列表页面
func _getList(c *gin.Context) {
	// 搜索和分页
	articleList := []ArticleModel{
		{"Go语言入门", "这篇文章是Go语言入门"},
		{"红宝书", "这篇文章是JS红宝书"},
	}
	c.JSON(200, articleList)
}
 
func _getDetail(c *gin.Context) {
	// 获取param中的id
	fmt.Println(c.Param("id"))
	article := ArticleModel{"红宝书", "这篇文章是JS红宝书"}
	c.JSON(200, article)
}
 
// 创建文章
func _create(c *gin.Context) {
	// 接收前端传来的JSON数据
	var article ArticleModel
	err := _bindJson(c, &article)
	if err != nil {
		fmt.Println(err)
		return
	}
	c.JSON(200, article)
}
 
func _update(c *gin.Context) {
	// 接收前端传来的JSON数据
	fmt.Println(c.Param("id"))
	var article ArticleModel
	err := _bindJson(c, &article)
	if err != nil {
		fmt.Println(err)
		return
	}
	c.JSON(200, article)
}
 
func _delete(c *gin.Context) {
	fmt.Println(c.Param("id"))
	c.JSON(200, gin.H{})
}
 
func main() {
	router := gin.Default()
	//gin.SetMode(gin.DebugMode)
	//router.GET("/articles", _getList)
	//router.GET("/articles", _getDetail)
	//router.POST("/articles", _create)
	//router.POST("/articles/:id", _update)
	router.POST("/articles/:id", _delete)
	router.Run(":80")
}

请求头相关：

请求头参数获取

GetHeader可以大小写部分，且返回切片中的第一个数据

 func main() {
 
	router := gin.Default()
	// 请求头的各种获取方式
	router.GET("/", func(c *gin.Context) {
		//首字母大小写不区分，单词与单词之间用-连接
		// 用于获取一个请求头
		fmt.Println(c.GetHeader("User-Agent"))
		fmt.Println(c.GetHeader("User-agent"))
		fmt.Println(c.GetHeader("user-Agent"))
 
		//Header 是一个普通的map[string] []string
		fmt.Println(c.Request.Header)
		// 如果是使用Get方法或者 .GetHeader, 哪么可以不用区分大小写，并且返回第一个value
		fmt.Println(c.Request.Header.Get("User-Agent"))
		fmt.Println(c.Request.Header["User-Agent"])
		// 如果是map的取值方式，请注意大小写问题
		fmt.Println(c.Request.Header["user-agent"])
 
		// 自定义的请求头，用Get方法也是免大小写
		fmt.Println(c.Request.Header.Get("Token"))
		fmt.Println(c.Request.Header.Get("token"))
		c.JSON(200, gin.H{"msg": "成功"})
	})
 
	// 爬虫和用户区别对待
	router.GET("/index", func(c *gin.Context) {
		userAgent := c.GetHeader("User-Agent")
		// 用正则去匹配
		// 字符串的包含匹配
		if strings.Contains(userAgent, "python") {
			// 爬虫来了
			c.JSON(0, gin.H{"data": "这是响应给爬虫的数据"})
			return
		}
	})
 
	router.Run(":80")
}

响应头相关：

 // 设置响应头
router.GET("/res", func(c *gin.Context) {
    c.Header("Token", "123asdasda45646asd")
    c.Header("Content-Type", "application/text; charset=utf-8") // 浏览器会当成文本直接下载
    c.JSON(0, gin.H{"data": "看看响应头"})
})

参数绑定：

gin中的bind可以很方便的进行参数绑定及参数校验

使用这个功能的时候，需要给结构体加上Tag：json 、form、url、xml、yaml

Must Bind

不用，校验失败会改状态码

Should Bind

可以绑定json、query、param、yaml、xml

如果校验不通过会返回错误

 package main
 
import "github.com/gin-gonic/gin"
 
type UserInfo struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
	Sex  string `json:"sex"`
}
 
func main() {
	router := gin.Default()
	router.POST("/", func(c *gin.Context) {
 
		var userInfo UserInfo
		err := c.ShouldBind(&userInfo)
		if err != nil {
			c.JSON(200, gin.H{"msg": "你错了"})
			return
		}
		c.JSON(200, userInfo)
	})
	router.Run(":80")
}

ShouldBindQuery

绑定查询参数：

tag对应为form

 type UserInfo struct {
	Name string `json:"name" form:"name"`
	Age  int    `json:"age" form:"age"`
	Sex  string `json:"sex" form:"sex"`
}
 
func main() {
	router := gin.Default()
	router.POST("/query", func(c *gin.Context) {
		var userInfo UserInfo
		err := c.ShouldBindQuery(&userInfo)
		if err != nil {
			fmt.Println(err)
			c.JSON(200, gin.H{"msg": "你错了"})
			return
		}
		c.JSON(200, userInfo)
	})
 
	router.Run(":80")
}

ShouldBindUri

tag对应uri

 type UserInfo struct {
	Name string `json:"name" form:"name" uri:"name"`
	Age  int    `json:"age" form:"age" uri:"age"`
	Sex  string `json:"sex" form:"sex" uri:"sex"`
}
 
func main() {
	router := gin.Default()
	router.POST("/uri/:name/:age/:sex", func(c *gin.Context) {
		var userInfo UserInfo
		err := c.ShouldBindUri(&userInfo)
		if err != nil {
			fmt.Println(err)
			c.JSON(200, gin.H{"msg": "你错了"})
			return
		}
		c.JSON(200, userInfo)
	})
 
	router.Run(":80")
}

绑定formData

会根据请求头中的content-type去自动绑定

form-data的参数也用这个，tag用form

默认的tag就是form

绑定form-data、x-www-form-urlencode

 type UserInfo struct {
	Name string `form:"name"`
	Age  int    `form:"age"`
	Sex  string `form:"sex"`
}
 
func main() {
	router := gin.Default()
	router.POST("/form", func(c *gin.Context) {
		var userInfo UserInfo
		err := c.ShouldBind(&userInfo)
		if err != nil {
			fmt.Println(err)
			c.JSON(200, gin.H{"msg": "你错了"})
			return
		}
		c.JSON(200, userInfo)
	})
 
	router.Run(":80")
}

四、验证器

需要使用参数验证功能，需要加binding tag

常用验证器：

配置	作用	示例
required	必填字段	binding:"min=5"
min	最小长度	binding:"max=10"
max	最大长度	binding:"eq=3"
len	长度	binding:"len=6"
eq	等于	binding:"eq=3"
ne	不等于	binding:"ne=12"
gt	大于	binding:"gt=10"
gte	大于等于	binding:"gte=10"
lt	小于	binding:"lt=10"
lte	小于等于	binding:"lte=10"
eqfield	等于其他字段的值	PassWord string `binding:"eqfield=ConfirmPassword"`
nefield	不等于其他字段的值
-	忽略字段	binding:"-"

 package main
 
import "github.com/gin-gonic/gin"
 
type SignUserInfo struct {
	//Name       string `json:"name" binding:"required"` // 用户名
	Name     string `json:"name" binding:"min=4,max=6"` // 用户名
	Age      int    `json:"age"`                        // 年龄
	Password string `json:"password"`                   // 密码
	//RePassword string `json:"re_password"`                // 确认密码
	RePassword string `json:"re_password" binding:"eqfield=Password"` // 确认密码
}
 
func main() {
	router := gin.Default()
	router.POST("/", func(c *gin.Context) {
		var user SignUserInfo
		err := c.ShouldBindJSON(&user)
		if err != nil {
			c.JSON(200, gin.H{"msg": err.Error()})
		}
		c.JSON(200, gin.H{"msg": user})
	})
	router.Run(":80")
}

gin内置验证器：

url是uri的子集

 /*
枚举  只能是red或green
oneof=red green
 
字符串
contains=hello   包含hello的字符串
excludes  不包含
startswith 字符串前缀
endswith  字符串后缀
 
数组
dive  dive后面的验证就是针对数组中的每一个元素
 
网络验证
ip
ipv4
ipv6
uri     在于I（Identifier）是统一资源标示符，可以唯一标识一个资源
url     在于Locater,是统一资源定位符，提供找到该资源的确切路径
 
日期验证
datetime=2006-01-02 15:04:05
 
*/

 package main
 
import "github.com/gin-gonic/gin"
 
type SignUserInfo struct {
	//Name       string `json:"name" binding:"required"` // 用户名
	//Name     string `json:"name" binding:"min=4,max=6"` // 用户名
	//Name string `json:"name" binding:"excludes=f"` // 用户名   不包含f
	//Name string `json:"name" binding:"startswith=f"` // 用户名   前缀为f
	Name     string   `json:"name" binding:"endswith=f"` // 用户名   后缀为f
	LikeList []string `json:"like_list" binding:"required,dive,startswith=like"`
	IP       string   `json:"ip" binding:"ip"`                             // 需要满足ip要求
	Url      string   `json:"url" binding:"url"`                           // 满足url要求
	Uri      string   `json:"uri" binding:"uri"`                           // 满足url要求
	Age      int      `json:"age"`                                         // 年龄
	Password string   `json:"password"`                                    // 密码
	Date     string   `json:"date" binding:"datetime=2006-01-02 15:04:05"` // 1月2日下午3点4分5秒在2006年
	//RePassword string `json:"re_password"`                // 确认密码
	RePassword string `json:"re_password" binding:"eqfield=Password"` // 确认密码
	Sex        string `json:"sex" binding:"oneof=man woman"`          //枚举
}
 
func main() {
	router := gin.Default()
	router.POST("/", func(c *gin.Context) {
		var user SignUserInfo
		err := c.ShouldBindJSON(&user)
		if err != nil {
			c.JSON(200, gin.H{"msg": err.Error()})
		}
		c.JSON(200, gin.H{"msg": user})
	})
	router.Run(":80")
}

自定义验证的错误信息：

 package main
 
import (
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"reflect"
)
 
// 获取结构体中的msg参数
func GetValidMsg(err error, obj any) string {
	getObj := reflect.TypeOf(obj) // 拿到值
	// 将err接口断言为具体类型
	if errs, ok := err.(validator.ValidationErrors); ok {
		// 断言成功
		for _, e := range errs {
			// 循环每一个错误信息
			// 根据报错字段获取结构体具体字段
			if f, exits := getObj.Elem().FieldByName(e.Field()); exits {
				msg := f.Tag.Get("msg")
				return msg
			}
		}
	}
	return ""
}
 
func main() {
	router := gin.Default()
	router.POST("/", func(c *gin.Context) {
		type User struct {
			Name string `json:"name" binding:"required" msg:"用户名校验失败"`
			Age  int    `json:"age" binding:"required" msg:"请输入年龄"`
		}
		var user User
		err := c.ShouldBindJSON(&user)
		if err != nil {
			c.JSON(200, gin.H{"msg": GetValidMsg(err, &user)})
			return
		}
		c.JSON(200, gin.H{"data": user})
		return
	})
	router.Run(":80")
}

自定义绑定器：

 package main
 
import (
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/validator/v10"
	"reflect"
)
 
// 获取结构体中的msg参数
func _GetValidMsg(err error, obj any) string {
	getObj := reflect.TypeOf(obj) // 拿到值
	// 将err接口断言为具体类型
	if errs, ok := err.(validator.ValidationErrors); ok {
		// 断言成功
		for _, e := range errs {
			// 循环每一个错误信息
			// 根据报错字段获取结构体具体字段
			if f, exits := getObj.Elem().FieldByName(e.Field()); exits {
				msg := f.Tag.Get("msg")
				return msg
			}
		}
	}
	return err.Error()
}
 
type User struct {
	Name string `json:"name" binding:"required,sign" msg:"用户名校验失败"`
	Age  int    `json:"age" binding:"required" msg:"请输入年龄"`
}
 
func signValid(fl validator.FieldLevel) bool {
	var nameList []string = []string{"辉哥", "龙哥", "灿哥"}
	for _, nameStr := range nameList {
		name := fl.Field().Interface().(string)
		if name == nameStr {
			return false
		}
	}
	return true
}
 
func main() {
	router := gin.Default()
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		v.RegisterValidation("sign", signValid)
	}
 
	router.POST("/", func(c *gin.Context) {
 
		var user User
		err := c.ShouldBindJSON(&user)
		if err != nil {
			c.JSON(200, gin.H{"msg": _GetValidMsg(err, &user)})
			return
		}
		c.JSON(200, gin.H{"data": user})
		return
	})
	router.Run(":80")
}

五、文件

文件上传：

单文件：

SaveUploadFile

 c.SaveUploadFile(file,dst)   // 文件对象 文件路径，注意要从新项目根路径开始写

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
	"io"
	"os"
)
 
func main() {
	router := gin.Default()
	router.POST("/upload", func(c *gin.Context) {
		file, _ := c.FormFile("file")
		readerFile, _ := file.Open()
		// 也可以使用os.Create
		writeFile, _ := os.Create("./upload/13.png")
		defer writeFile.Close()
		n, _ := io.Copy(writeFile, readerFile) // 拷贝
		fmt.Println("n=", n)
 
		//fmt.Println(string(data))
		//fmt.Println(file.Filename)
		fmt.Println(file.Size / 1024) // 单位是字节
		c.SaveUploadedFile(file, "./upload/12.png")
		c.JSON(200, gin.H{"msg": "上传成功"})
	})
	router.Run(":80")
}

多个文件：

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
	"io"
	"os"
)
 
func main() {
	router := gin.Default()
	router.POST("/upload", func(c *gin.Context) {
		file, _ := c.FormFile("file")
		readerFile, _ := file.Open()
		// 也可以使用os.Create
		writeFile, _ := os.Create("./upload/13.png")
		defer writeFile.Close()
		n, _ := io.Copy(writeFile, readerFile) // 拷贝
		fmt.Println("n=", n)
 
		//fmt.Println(string(data))
		//fmt.Println(file.Filename)
		fmt.Println(file.Size / 1024) // 单位是字节
		c.SaveUploadedFile(file, "./upload/12.png")
		c.JSON(200, gin.H{"msg": "上传成功"})
	})
 
	router.POST("/uploads", func(c *gin.Context) {
		form, _ := c.MultipartForm()
		files, _ := form.File["upload[]"]
		for _, file := range files {
			c.SaveUploadedFile(file, "./uploads/"+file.Filename)
		}
		c.JSON(200, gin.H{"msg": fmt.Sprintf("成功上传%d个文件", len(files))})
	})
 
	router.Run(":80")
}

文件下载：

直接响应一个路径下的文件

 c.File("uploads/12.png")

有些响应，比如图片，浏览器就会显示这个图片，而不是下载，所以我们需要使浏览器唤起下载行为

 c.Header("Content-Type","application/octet-stream")  // 表示是文件流，唤起浏览器下载，一般设置了这个就需要设置文件名
c.Header("Content-Dispositon","attachment;filename="+"test.png")  // 用来指定下载下来的文件名
c.Header("Content-Transfer-Encoding","binary")  // 表示传输过程中的编码形式，乱码问题可能就是因为它
c.File("uploads/test.png")

注意：文件下载浏览器可能会有缓存，这个需要注意一下，解决办法就是加查询参数

前端在写的时候要

 this.$http({
    method:"post",
    utl:"file/upload",
    data:postData,
    responseType:"blob"   // 前端要加这个
}).then(res=>{})

 package main
 
import "github.com/gin-gonic/gin"
 
func main() {
	router := gin.Default()
	router.GET("/download", func(c *gin.Context) {
		c.Header("Content-Type", "application/octet-stream")            // 表示是文件流，唤起浏览器下载，一般设置了这个就需要设置文件名
		c.Header("Content-Dispositon", "attachment;filename="+"12.png") // 用来指定下载下来的文件名
		c.File("upload/12.png")                                         // 这样会直接在网页预览
	})
	router.Run(":8080")
}

六、gin中间件和路由

Gin框架允许开发者在处理请求中，加入用户自己的钩子（Hook）函数，这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录认证、权限教研、数据分页、记录日志、耗时统计等。比如，如果访问一个网页的话，不管访问什么路径都需要进行登录，此时就需要为所有路径处理函数进行统一一个中间件

Gin的中间件必须是一个gin.HandlerFunc类型

单独注册中间件：

c.Next()之前的就是请求中间件，之后的就是响应中间件

如果其中一个中间件响应了c.Abort()，后续中间件将不再执行，直接按照顺序走完所有的响应中间件

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
)
 
func m1(c *gin.Context) {
	fmt.Println("m1 in ...")
	//c.Abort() // 使用这个方法之后，就不会响应后面的了
	c.Next()
	fmt.Println("m1 out ...")
	//c.JSON(200, gin.H{"msg": "index"})
 
}
 
func index(c *gin.Context) {
	fmt.Println("index ... in")
	c.JSON(200, gin.H{"msg": "index"})
	c.Next()
	fmt.Println("index ...out")
}
 
func m2(c *gin.Context) {
	fmt.Println("m2 in ...")
	c.Next()
	//c.JSON(200, gin.H{"msg": "index"})
	fmt.Println("m2 out ...")
}
 
func main() {
	router := gin.Default()
	router.GET("/", m1, index, m2)
	router.Run(":8080")
}

全局中间件和中间件传参：

全局注册中间件：

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
)
 
func m10(c *gin.Context) { // 全局中间件
	fmt.Println("m10...in")
	c.JSON(200, gin.H{"msg": "响应被我吃掉了"})
	c.Abort()
	c.Next()
	fmt.Println("m10...out")
}
func m11(c *gin.Context) { // 全局中间件
	fmt.Println("m11...in")
	c.Next()
	fmt.Println("m11...out")
}
 
func main() {
	router := gin.Default()
	router.Use(m10, m11) // 注册中间件
	router.GET("/m10", func(c *gin.Context) {
		fmt.Println("index...in")
		c.JSON(200, gin.H{"msg": "m10"})
		c.Next()
		fmt.Println("index...out")
	})
	router.GET("/m11", func(c *gin.Context) {
		c.JSON(200, gin.H{"msg": "m11"})
	})
	router.Run(":8080")
}

中间件传递数据：

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
)
 
type User struct {
	Name string
	Age  int
}
 
func m10(c *gin.Context) { // 全局中间件
	fmt.Println("m10...in")
	c.JSON(200, gin.H{"msg": "响应被我吃掉了"})
	c.Set("name", "zzz")
	c.Set("user", User{
		Name: "test",
		Age:  25,
	})
	//c.Abort()
	//c.Next()
	fmt.Println("m10...out")
}
func m11(c *gin.Context) { // 全局中间件
	fmt.Println("m11...in")
	c.Next()
	fmt.Println("m11...out")
}
 
func main() {
	router := gin.Default()
	router.Use(m10, m11) // 注册中间件
	router.GET("/m10", func(c *gin.Context) {
		fmt.Println("index...in")
		c.JSON(200, gin.H{"msg": "m10"})
		name, _ := c.Get("name")
		fmt.Println(name)
		_user, _ := c.Get("user")
		user := _user.(User) // 如果需要用到user中的某一个字段，需要断言
		fmt.Println(user.Name)
		c.Next()
		fmt.Println("index...out")
	})
	router.GET("/m11", func(c *gin.Context) {
		c.JSON(200, gin.H{"msg": "m11"})
	})
	router.Run(":8080")
}

路由分组：

将一系列路由放到一个组下，统一管理

 package main
 
import "github.com/gin-gonic/gin"
 
type UserInfo struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}
 
type ArticleInfo struct {
	Title   string `json:"title"`
	Content string `json:"content"`
}
 
type Response struct {
	Code int    `json:"code"`
	Data any    `json:"data"`
	Msg  string `json:"msg"`
}
 
func UserList(c *gin.Context) {
	var userList []UserInfo = []UserInfo{
		{"book", 21},
		{"li", 22},
		{"wang", 23},
	}
	c.JSON(200, Response{
		Code: 0,
		Data: userList,
		Msg:  "请求成功",
	})
}
func articleList(c *gin.Context) {
	var userList = []ArticleInfo{
		{"go", "从0到1"},
		{"python", "从0到1"},
	}
	c.JSON(200, Response{
		Code: 0,
		Data: userList,
		Msg:  "请求成功",
	})
}
 
func main() {
	router := gin.Default()
 
	api := router.Group("api")
	userManger := api.Group("user_manager")
	{
		userManger.GET("/users", UserList) // 访问需要/api/user_manager/users
	}
	articleManager := api.Group("article_manager")
	{
		articleManager.GET("/articles", articleList)
	}
	//api.GET("/users", UserList)        // 访问需要/api/users
	//router.GET("/users", UserList)
	router.Run(":8080")
}

路由分组中间件：

 package main
 
import "github.com/gin-gonic/gin"
 
type UserInfo struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}
 
type ArticleInfo struct {
	Title   string `json:"title"`
	Content string `json:"content"`
}
 
type Response struct {
	Code int    `json:"code"`
	Data any    `json:"data"`
	Msg  string `json:"msg"`
}
 
func UserList(c *gin.Context) {
	var userList []UserInfo = []UserInfo{
		{"book", 21},
		{"li", 22},
		{"wang", 23},
	}
	c.JSON(200, Response{
		Code: 0,
		Data: userList,
		Msg:  "请求成功",
	})
}
func articleList(c *gin.Context) {
	var userList = []ArticleInfo{
		{"go", "从0到1"},
		{"python", "从0到1"},
	}
	c.JSON(200, Response{
		Code: 0,
		Data: userList,
		Msg:  "请求成功",
	})
}
 
func MiddleWare(c *gin.Context) {
	token := c.GetHeader("token")
	if token == "1234" {
		c.Next()
		return
	}
	c.JSON(200, Response{
		Code: 200,
		Data: nil,
		Msg:  "权限验证失败",
	})
}
 
func main() {
	router := gin.Default()
	//router := gin.New()  // 不含任何中间件
 
	api := router.Group("api")
	userManger := api.Group("user_manager").Use(MiddleWare)
	{
		userManger.GET("/users", UserList) // 访问需要/api/user_manager/users
	}
	articleManager := api.Group("article_manager")
	{
		articleManager.GET("/articles", articleList)
	}
	//api.GET("/users", UserList)        // 访问需要/api/users
	//router.GET("/users", UserList)
	router.Run(":8080")
}

七、日志

gin内置日志组件：

为什么要使用日志

记录用户操作，猜测用户行为
记录bug

环境切换不想看到debug日志可以改为release模式

 gin.SetMode(gin.ReleaseMode)
router := gin.Default()

自定义输出格式

 package main
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
	"log"
)
 
func main() {
	gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
		log.Printf(
			"%s %s %s %d \n",
			httpMethod,
			absolutePath,
			handlerName,
			nuHandlers,
		)
	}
	//router := gin.Default()
	router := gin.New()
	router.Use(gin.LoggerWithFormatter(func(params gin.LogFormatterParams) string {
		return fmt.Sprintf(
			"%s |%d| %s %s\n",
			params.TimeStamp.Format("2006-01-02 15:04:05"),
			params.StatusCode,
			params.Method,
			params.MethodColor(), // 可以修改颜色
			params.Path,
		)
	}))
	router.GET("/index", func(c *gin.Context) {})
	router.POST("/users", func(c *gin.Context) {})
	router.POST("/articles", func(c *gin.Context) {})
	router.DELETE("/articles/:id", func(c *gin.Context) {})
	fmt.Println(router.Routes()) // 会把所有路由打印下来
	router.Run(":8080")
}

输出带颜色

 fmt.Printf("\033[97;41m红底白字\033[0m 正常颜色")

logrus:

下载：

 go get github.com/sirupsen/logrus

日志等级：

 PanicLevel  // 会抛一个异常
FatalLevel  // 打印日志之后就会退出
ErrorLevel
WarnLevel
InfoLevel
DebugLevel
TraceLevel  // 低级别

更改日志级别：

 logrus.SetLevel(logrus.WarnLevel) // 设置日志等级

 package main
 
import (
	"fmt"
	"github.com/sirupsen/logrus"
)
 
const (
	cBlack = 0
	cRed   = 1
	cGreen = 2
)
 
func PrintColor(colorCode int, text string) {
	fmt.Printf("\033[3%dm%s\033[0m", colorCode, text)
}
 
func main() {
 
	PrintColor(cRed, "红色")
	logrus.SetFormatter(&logrus.TextFormatter{
		ForceColors:     true,
		FullTimestamp:   true,
		TimestampFormat: "2006-01-02 15:04:05",
	})
	logrus.SetLevel(logrus.DebugLevel)
	logrus.SetLevel(logrus.WarnLevel) // 设置日志等级
	logrus.SetLevel(logrus.InfoLevel) // 设置日志等级
	logrus.Errorf("出错了")
	logrus.Warnln("警告")
	logrus.Infof("信息")
	logrus.Debugf("debug")
	logrus.Println("打印")
 
	fmt.Println(logrus.GetLevel())               // 显示等级
	logrus.SetFormatter(&logrus.JSONFormatter{}) // 用JSON显示
	logrus.SetFormatter(&logrus.TextFormatter{   // 设置颜色
		ForceColors: true,
	})
 
	log := logrus.WithField("app", "study").WithField("service", "logrus") // 可以链式调用
	log = logrus.WithFields(logrus.Fields{
		"user": "ww",
		"ip":   "192.168.200.254",
	})
	log.Errorf("你好") // 会统一加上上面的字段
 
	fmt.Println("\033[31m 红色 \033[0m") // 设置字体颜色
	fmt.Println("\033[41m 红色 \033[0m") // 设置背景颜色
}

自定义格式：

输出到日志文件

 package main
 
import (
	"github.com/sirupsen/logrus"
	"io"
	"os"
)
 
func main() {
	file, _ := os.OpenFile("logrus_study/info.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
 
	logrus.SetOutput(io.MultiWriter(file, os.Stdout)) // 同时输出屏幕和文件
	logrus.Infof("你好")
	logrus.Error("出错了")
	logrus.Errorf("出错了")
	logrus.Errorln("出错了")
}

自定义输出格式：

 func main() {
    router := gin.New()
    // LoggerWithFormatter middleware will write the logs to gin.DefaultWrite
    // By default gin.DefaultWriter = os.Stdout
    router.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
        // your custom format
        return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",
            param.ClientIP,
            param.TimeStamp.Format(time.RFC1123),
            param.Method,
            param.Path,
            param.Request.Proto,
            param.StatusCode,
            param.Latency,
            param.Request.UserAgent(),
            param.ErrorMessage,
        )
    }))
    router.Use(gin.Recovery())
    router.GET("/ping", func(c *gin.Context) {
        c.String(200, "pong")
    })
    router.Run(":8080")
}

显示行号：

 logrus.SetReportCaller(true)

hook：

初始化时为logrus添加hook，logrus可以实现各种扩展功能

 // logrus在记录Levels()返回的日志级别的消息时会触发HOOK
// 按照Fire方法定义的内容修改logrus.Entry
type Hook interface {
    Levels() []Level
    Fire(*Entry) error
}

gin集成logrus:

use使用中间件，把logrus单独放一个文件中，然后引入进来

初始化日志器和日志实例

 package util
 
import (
    "fmt"
    rotatelogs "github.com/lestrrat-go/file-rotatelogs"
    "github.com/rifflock/lfshook"
    "github.com/sirupsen/logrus"
    "os"
    "time"
)
 
var (
	Logger = logrus.New()  // 初始化日志对象
	LogEntry *logrus.Entry
)
 
 
func init() {
    // 写入日志文件
    logPath := "logs/log"  // 日志存放路径
    linkName := "logs/latest.log"  // 最新日志的软连接路径
    src, err := os.OpenFile(logPath, os.O_RDWR|os.O_CREATE, 0755)  // 初始化日志文件对象
    if err != nil {
        fmt.Println("err: ", err)
    }
    //log := logrus.New()  // 初始化日志对象
    Logger.Out = src  // 把产生的日志内容写进日志文件中
 
    // 日志分隔：1. 每天产生的日志写在不同的文件；2. 只保留一定时间的日志（例如：一星期）
    Logger.SetLevel(logrus.DebugLevel)  // 设置日志级别
    logWriter, _ := rotatelogs.New(
        logPath + "%Y%m%d.log",  // 日志文件名格式
        rotatelogs.WithMaxAge(7 * 24 * time.Hour),  // 最多保留7天之内的日志
        rotatelogs.WithRotationTime(24*time.Hour),  // 一天保存一个日志文件
        rotatelogs.WithLinkName(linkName),  // 为最新日志建立软连接
    )
    writeMap := lfshook.WriterMap{
        logrus.InfoLevel: logWriter,  // info级别使用logWriter写日志
        logrus.FatalLevel: logWriter,
        logrus.DebugLevel: logWriter,
        logrus.ErrorLevel: logWriter,
        logrus.PanicLevel: logWriter,
    }
    Hook := lfshook.NewHook(writeMap, &logrus.TextFormatter{
        TimestampFormat: "2006-01-02 15:04:05",  // 格式日志时间
    })
    Logger.AddHook(Hook)
    LogEntry = logrus.NewEntry(Logger).WithField("service", "yi-shou-backstage")
}

在项目中使用定义的日志实例记录日志

 // user列表
func ListUsers(ctx *gin.Context){
    util.LogEntry.Error("用户列表")
    ctx.JSON(200, gin.H{
        "message": "hello go",
    })
}

定义日志中间件，记录常见异常的日志信息

 package middleware
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "github.com/sirupsen/logrus"
    "math"
    "time"
    "yi-shou-backstage/util"
)
 
func LoggerMiddleware() gin.HandlerFunc{
    return func(c *gin.Context) {
        startTime := time.Now()
        c.Next()  // 调用该请求的剩余处理程序
        stopTime := time.Since(startTime)
        spendTime := fmt.Sprintf("%d ms", int(math.Ceil(float64(stopTime.Nanoseconds() / 1000000))))
        //hostName, err := os.Hostname()
        //if err != nil {
        //    hostName = "Unknown"
        //}
        statusCode := c.Writer.Status()
        //clientIP := c.ClientIP()
        //userAgent := c.Request.UserAgent()
        dataSize := c.Writer.Size()
        if dataSize < 0 {
            dataSize = 0
        }
        method := c.Request.Method
        url := c.Request.RequestURI
        Log := util.Logger.WithFields(logrus.Fields{
            //"HostName": hostName,
            "SpendTime": spendTime,
            "path": url,
            "Method": method,
            "status": statusCode,
            //"Ip": clientIP,
            //"DataSize": dataSize,
            //"UserAgent": userAgent,
        })
        if len(c.Errors) > 0 {  // 矿建内部错误
            Log.Error(c.Errors.ByType(gin.ErrorTypePrivate))
        }
        if statusCode >= 500 {
            Log.Error()
        } else if statusCode >= 400 {
            Log.Warn()
        }else {
            Log.Info()
        }
    }
}

gin集成自定义的中间件

 router := gin.New()
// 注册自定义的日志器
router.Use(middleware.LoggerMiddleware())

本文作者：喵喵队立大功

本文链接：https://www.cnblogs.com/oaoa/p/17115273.html

posted @ 2023-02-13 09:19 喵喵队立大功阅读(235) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

	package main

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

	func _string(c *gin.Context) {
	c.String(200, "你好呀")
	}

	func _json(c *gin.Context) {
	// json响应结构体
	//type Userinfo struct {
	// UserName string `json:"user_name"`
	// Age int `json:"age"`
	// Password string `json:"-"` // 忽略会转换成json
	//}
	//user := Userinfo{
	// UserName: "百香果",
	// Age: 23,
	//}

	// json响应map
	//userMap := map[string]string{
	// "username": "草莓",
	// "age": "25",
	//}

	// 直接响应json
	c.JSON(200, gin.H{"userName": "芒果", "age": "26"})

	//c.JSON(200, user)
	//c.JSON(200, userMap)
	}

	func main() {
	router := gin.Default()
	router.GET("/", _string)
	router.GET("/json", _json)
	router.Run(":80")
	}

	// 响应xml
	func _xml(c *gin.Context) {
	c.XML(200, gin.H{"userName": "芒果", "age": "26", "status": http.StatusOK, "data": gin.H{"user": "菠萝"}})
	}

	// 响应yaml
	func _yaml(c *gin.Context) {
	c.YAML(200, gin.H{"userName": "芒果", "age": "26", "status": http.StatusOK, "data": gin.H{"user": "菠萝"}})
	}

	func main() {
	router := gin.Default()
	router.GET("/xml", _xml)
	router.GET("/yaml", _yaml)
	router.Run(":80")
	}

	// 响应html
	func _html(c *gin.Context) {
	c.HTML(200, "index.html", gin.H{"username": "铃兰"})
	}
	func main() {
	router := gin.Default()
	router.LoadHTMLGlob("templates/*") // 要把html文件加载进来
	router.GET("/html", _html)
	router.Run(":80")
	}

	package main

	import (
	"github.com/gin-gonic/gin"
	"net/http"
	)

	func _string(c *gin.Context) {
	c.String(200, "你好呀")
	}

	func main() {
	router := gin.Default()
	// 加载模板目录下的所有模板文件
	router.LoadHTMLGlob("templates/*") // 要把html文件加载进来
	// 在go中，没有相对文件的路径，只有相对项目的路径
	// 这样可以做到只拿到static/static下面的文件，static下面的文件不指定无法获取到
	// 网页请求静态目录的前缀，后面是http.Dir方法，是一个目录，注意前缀不要重复
	router.StaticFS("/static", http.Dir("static/static"))
	// 配置单个文件，网页请求的路由，文件的路径
	router.StaticFile("/cat.png", "static/cat.png")
	router.Run(":80")
	}

	package main

	import (
	"fmt"
	"github.com/gin-gonic/gin"
	)

	func _query(c *gin.Context) {
	fmt.Println(c.Query("user"))
	fmt.Println(c.GetQuery("user"))
	fmt.Println(c.QueryArray("user")) // 如果传了多个user，拿到相同的查询参数
	fmt.Println(c.DefaultQuery("addr", "北京")) // 用户没传就使用默认值
	}

	func main() {
	router := gin.Default()
	router.GET("/query", _query)
	router.Run(":80")
	}

	func _form(c *gin.Context) {
	fmt.Println(c.PostForm("name"))
	fmt.Println(c.PostFormArray("name"))
	fmt.Println(c.DefaultPostForm("addr", "北京")) // 如果用户没有传就使用默认值
	forms, err := c.MultipartForm() // 接收所有的form参数，包括文件
	fmt.Println(forms, err)
	}
	func main() {
	router := gin.Default()
	router.POST("/form", _form)
	router.Run(":80")
	}

	func _bindJson(c *gin.Context, obj any) (err error) {
	body, _ := c.GetRawData()
	contentType := c.GetHeader("Content-Type")
	fmt.Println(contentType)
	switch contentType {
	case "application/json": // 解析json数据
	err := json.Unmarshal(body, &obj)
	if err != nil {
	fmt.Println(err.Error())
	return err
	}
	}
	return nil
	}

	func _raw(c *gin.Context) {
	type User struct {
	Name string `json:"name"`
	Age int `json:"age"`
	}
	var user User
	err := _bindJson(c, &user)
	if err != nil {
	fmt.Println(err)
	}
	fmt.Println(user)
	}
	func main() {
	router := gin.Default()
	router.POST("/raw", _raw)
	router.Run(":80")
	}

	/*
	以文字资源为例
	GET /articles 文章列表
	GET /articles/:id 文章详情
	POST /articles 添加文章
	PUT /articles/:id 修改某一篇文章
	DELETE /articles/:id 删除某一篇文章
	*/

	package main

	import (
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	)

	type ArticleModel struct {
	Title string `json:"title"`
	Content string `json:"content"`
	}

	func _bindJson(c *gin.Context, obj any) (err error) {
	body, _ := c.GetRawData()
	contentType := c.GetHeader("Content-Type")
	//fmt.Println(contentType)
	switch contentType {
	case "application/json": // 解析json数据
	err = json.Unmarshal(body, &obj)
	if err != nil {
	fmt.Println(err.Error())
	return err
	}
	}
	return nil
	}

	// 文章列表页面
	func _getList(c *gin.Context) {
	// 搜索和分页
	articleList := []ArticleModel{
	{"Go语言入门", "这篇文章是Go语言入门"},
	{"红宝书", "这篇文章是JS红宝书"},
	}
	c.JSON(200, articleList)
	}

	func _getDetail(c *gin.Context) {
	// 获取param中的id
	fmt.Println(c.Param("id"))
	article := ArticleModel{"红宝书", "这篇文章是JS红宝书"}
	c.JSON(200, article)
	}

	// 创建文章
	func _create(c *gin.Context) {
	// 接收前端传来的JSON数据
	var article ArticleModel
	err := _bindJson(c, &article)
	if err != nil {
	fmt.Println(err)
	return
	}
	c.JSON(200, article)
	}

	func _update(c *gin.Context) {
	// 接收前端传来的JSON数据
	fmt.Println(c.Param("id"))
	var article ArticleModel
	err := _bindJson(c, &article)
	if err != nil {
	fmt.Println(err)
	return
	}
	c.JSON(200, article)
	}

	func _delete(c *gin.Context) {
	fmt.Println(c.Param("id"))
	c.JSON(200, gin.H{})
	}

	func main() {
	router := gin.Default()
	//gin.SetMode(gin.DebugMode)
	//router.GET("/articles", _getList)
	//router.GET("/articles", _getDetail)
	//router.POST("/articles", _create)
	//router.POST("/articles/:id", _update)
	router.POST("/articles/:id", _delete)
	router.Run(":80")
	}

	func main() {

	router := gin.Default()
	// 请求头的各种获取方式
	router.GET("/", func(c *gin.Context) {
	//首字母大小写不区分，单词与单词之间用-连接
	// 用于获取一个请求头
	fmt.Println(c.GetHeader("User-Agent"))
	fmt.Println(c.GetHeader("User-agent"))
	fmt.Println(c.GetHeader("user-Agent"))

	//Header 是一个普通的map[string] []string
	fmt.Println(c.Request.Header)
	// 如果是使用Get方法或者 .GetHeader, 哪么可以不用区分大小写，并且返回第一个value
	fmt.Println(c.Request.Header.Get("User-Agent"))
	fmt.Println(c.Request.Header["User-Agent"])
	// 如果是map的取值方式，请注意大小写问题
	fmt.Println(c.Request.Header["user-agent"])

	// 自定义的请求头，用Get方法也是免大小写
	fmt.Println(c.Request.Header.Get("Token"))
	fmt.Println(c.Request.Header.Get("token"))
	c.JSON(200, gin.H{"msg": "成功"})
	})

	// 爬虫和用户区别对待
	router.GET("/index", func(c *gin.Context) {
	userAgent := c.GetHeader("User-Agent")
	// 用正则去匹配
	// 字符串的包含匹配
	if strings.Contains(userAgent, "python") {
	// 爬虫来了
	c.JSON(0, gin.H{"data": "这是响应给爬虫的数据"})
	return
	}
	})

	router.Run(":80")
	}

	// 设置响应头
	router.GET("/res", func(c *gin.Context) {
	c.Header("Token", "123asdasda45646asd")
	c.Header("Content-Type", "application/text; charset=utf-8") // 浏览器会当成文本直接下载
	c.JSON(0, gin.H{"data": "看看响应头"})
	})

	package main

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

	type UserInfo struct {
	Name string `json:"name"`
	Age int `json:"age"`
	Sex string `json:"sex"`
	}

	func main() {
	router := gin.Default()
	router.POST("/", func(c *gin.Context) {

	var userInfo UserInfo
	err := c.ShouldBind(&userInfo)
	if err != nil {
	c.JSON(200, gin.H{"msg": "你错了"})
	return
	}
	c.JSON(200, userInfo)
	})
	router.Run(":80")
	}

	type UserInfo struct {
	Name string `json:"name" form:"name"`
	Age int `json:"age" form:"age"`
	Sex string `json:"sex" form:"sex"`
	}

	func main() {
	router := gin.Default()
	router.POST("/query", func(c *gin.Context) {
	var userInfo UserInfo
	err := c.ShouldBindQuery(&userInfo)
	if err != nil {
	fmt.Println(err)
	c.JSON(200, gin.H{"msg": "你错了"})
	return
	}
	c.JSON(200, userInfo)
	})

	router.Run(":80")
	}

	type UserInfo struct {
	Name string `json:"name" form:"name" uri:"name"`
	Age int `json:"age" form:"age" uri:"age"`
	Sex string `json:"sex" form:"sex" uri:"sex"`
	}

	func main() {
	router := gin.Default()
	router.POST("/uri/:name/:age/:sex", func(c *gin.Context) {
	var userInfo UserInfo
	err := c.ShouldBindUri(&userInfo)
	if err != nil {
	fmt.Println(err)
	c.JSON(200, gin.H{"msg": "你错了"})
	return
	}
	c.JSON(200, userInfo)
	})

	router.Run(":80")
	}

	type UserInfo struct {
	Name string `form:"name"`
	Age int `form:"age"`
	Sex string `form:"sex"`
	}

	func main() {
	router := gin.Default()
	router.POST("/form", func(c *gin.Context) {
	var userInfo UserInfo
	err := c.ShouldBind(&userInfo)
	if err != nil {
	fmt.Println(err)
	c.JSON(200, gin.H{"msg": "你错了"})
	return
	}
	c.JSON(200, userInfo)
	})

	router.Run(":80")
	}

	package main

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

	type SignUserInfo struct {
	//Name string `json:"name" binding:"required"` // 用户名
	Name string `json:"name" binding:"min=4,max=6"` // 用户名
	Age int `json:"age"` // 年龄
	Password string `json:"password"` // 密码
	//RePassword string `json:"re_password"` // 确认密码
	RePassword string `json:"re_password" binding:"eqfield=Password"` // 确认密码
	}

	func main() {
	router := gin.Default()
	router.POST("/", func(c *gin.Context) {
	var user SignUserInfo
	err := c.ShouldBindJSON(&user)
	if err != nil {
	c.JSON(200, gin.H{"msg": err.Error()})
	}
	c.JSON(200, gin.H{"msg": user})
	})
	router.Run(":80")
	}

	/*
	枚举只能是red或green
	oneof=red green

	字符串
	contains=hello 包含hello的字符串
	excludes 不包含
	startswith 字符串前缀
	endswith 字符串后缀

	数组
	dive dive后面的验证就是针对数组中的每一个元素

	网络验证
	ip
	ipv4
	ipv6
	uri 在于I（Identifier）是统一资源标示符，可以唯一标识一个资源
	url 在于Locater,是统一资源定位符，提供找到该资源的确切路径

	日期验证
	datetime=2006-01-02 15:04:05

	*/

	c.Header("Content-Type","application/octet-stream") // 表示是文件流，唤起浏览器下载，一般设置了这个就需要设置文件名
	c.Header("Content-Dispositon","attachment;filename="+"test.png") // 用来指定下载下来的文件名
	c.Header("Content-Transfer-Encoding","binary") // 表示传输过程中的编码形式，乱码问题可能就是因为它
	c.File("uploads/test.png")

	this.$http({
	method:"post",
	utl:"file/upload",
	data:postData,
	responseType:"blob" // 前端要加这个
	}).then(res=>{})

	PanicLevel // 会抛一个异常
	FatalLevel // 打印日志之后就会退出
	ErrorLevel
	WarnLevel
	InfoLevel
	DebugLevel
	TraceLevel // 低级别