数据解析和绑定
json数据解析和绑定
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
// 定义接受数据的结构体
type Login struct {
// binding:"required"修饰的字段，若接收为空值，则报错，是必须字段
User string `form:"username" json:"user" uri:"user" xml:"user" binding:"required"`
Pssword string `form:"password" json:"password" uri:"password" xml:"password" binding:"required"`
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// JSON绑定
r.POST("loginJSON", func(c *gin.Context) {
// 声明接收的变量
var json Login
// 将request的body中的数据，自动按照json格式解析到结构体
// ShouldBindQuery可以实现Get方式的数据请求的绑定.
if err := c.ShouldBindJSON(&json); err != nil {
// 返回错误信息
// gin.H封装了生成json数据的工具
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
// 判断用户名密码是否正确
if json.User != "root" || json.Pssword != "admin" {
c.JSON(http.StatusBadRequest, gin.H{"status": "304"})
return
}
c.JSON(http.StatusOK, gin.H{"status": "200"})
})
r.Run()
}
/*
curl http://127.0.0.1:8080/loginJSON -H 'content-type:application/json' -d "{"user":"root","password":"admin"}" -X POST
{"status":"200"}%
*/
表单数据解析和绑定
表单实体绑定
使用PostForm这种单个获取属性和字段的方式,代码量较多,需要一个一个属性进行获取, 而表单数据的提交, 往往对应着完整的数据结构体定义,其中对应着表单的输入项, gin框架提供了数据结构体和表单提交数据绑定的功能, 提高表单数据获取的效率.
gin_demo1.go
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
// 定义接受数据的结构体
type Login struct {
// binding:"required"修饰的字段，若接收为空值，则报错，是必须字段
User string `form:"username" json:"user" uri:"user" xml:"user" binding:"required"`
Pssword string `form:"password" json:"password" uri:"password" xml:"password" binding:"required"`
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// JSON绑定
r.POST("/loginFrom", func(c *gin.Context) {
// 声明接受的变量
var form Login
if err := c.Bind(&form); err != nil {
c.JSON(http.StatusBadRequest,gin.H{"error": err.Error()})
return
}
// 判断用户名密码是否正确
if form.User != "root" || form.Pssword != "admin" {
c.JSON(http.StatusBadRequest,gin.H{"status":"304"})
return
}
c.JSON(http.StatusOK,gin.H{"status":"200"})
})
r.Run()
}
login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="http://127.0.0.1:8080/loginFrom" method="post" enctype="multipart/form-data">
用户名: <input type="text" name="username">
密码: <input type="password" name="password">
<input type="submit" value="登录">
</form>
</body>
</html>
URL数据解析和绑定
gin_demo1.go
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
// 定义接受数据的结构体
type Login struct {
// binding:"required"修饰的字段，若接收为空值，则报错，是必须字段
User string `form:"username" json:"user" uri:"user" xml:"user" binding:"required"`
Pssword string `form:"password" json:"password" uri:"password" xml:"password" binding:"required"`
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// JSON绑定
r.GET("/:user/:password", func(c *gin.Context) {
// 声明接受的变量
var login Login
if err := c.ShouldBindUri(&login); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
if login.User != "root" || login.Pssword != "admin" {
c.JSON(http.StatusBadRequest,gin.H{"status":"304"})
return
}
c.JSON(http.StatusOK,gin.H{"status":"200"})
})
r.Run()
}
/*
curl http://127.0.0.1:8080/root/admin
{"status":"200"}%
*/
Gin渲染
各种数据格式的响应
json,结构体,xml, yaml类似于java的properties,protobuf
package main
import (
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/testdata/protoexample"
)
// 定义接受数据的结构体
type Login struct {
// binding:"required"修饰的字段，若接收为空值，则报错，是必须字段
User string `form:"username" json:"user" uri:"user" xml:"user" binding:"required"`
Pssword string `form:"password" json:"password" uri:"password" xml:"password" binding:"required"`
// 此处的binding用 required修饰,并且在绑定该字段的值为空,那么将返回一个错误
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// 1. JSON绑定
r.GET("/someJSON", func(c *gin.Context) {
c.JSON(200,gin.H{"message":"someJSON","status":200})
})
// 2. 结构体响应
r.GET("/someStruct", func(c *gin.Context) {
var msg struct{
Name string
Message string
Number int
}
msg.Name = "root"
msg.Message = "message"
msg.Number = 123
c.JSON(200,msg)
})
// 3. XML
r.GET("/someXML", func(c *gin.Context) {
c.XML(200,gin.H{"message":"abc"})
})
// 4. YAML
r.GET("/someYAML", func(c *gin.Context) {
c.YAML(200,gin.H{"name":"youmen"})
})
// 5.protobuf格式,谷歌开发的高效存储读取的工具
// 数组？切片？如果自己构建一个传输格式，应该是什么格式？
r.GET("/someProtoBuf", func(c *gin.Context) {
reps := []int64{int64(1),int64(2)}
// 定义数据
label := "label"
// 传protobuf格式数据
data := &protoexample.Test{
Label: &label,
Reps: reps,
}
c.ProtoBuf(200,data)
})
r.Run()
}
jsondemo1
package main
import (
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
"github.com/go-playground/validator/v10"
)
var a int
type PostParams struct {
Name string `json:"name"`
Age int `json:"age" binding:"required,mustBig"`
Sex bool `json:"sex"`
}
func mustBig(f1 validator.FieldLevel) bool {
if f1.Field().Interface().(int) <= 18 {
return false
}
return true
}
func main() {
r := gin.Default()
if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
v.RegisterValidation("mustBig", mustBig)
}
// GET和POST混合
r.POST("/testBind", func(c *gin.Context) {
var msg PostParams
err := c.ShouldBindJSON(&msg)
if err != nil {
c.JSON(404, gin.H{
"msg": "服务错误",
"data": gin.H{},
})
} else {
c.JSON(200, gin.H{
"msg": "成功了",
"data": msg,
})
}
})
r.Run()
}
HTML模板渲染
gin支持加载HTML模板,然后根据模板参数进行配置并返回相应的数据,本质上就是字符串替换.
LoadHTMLGlob()方法可以加载配置文件
HTML渲染
gin_demo1.go
package main
import (
"github.com/gin-gonic/gin"
)
// 定义接受数据的结构体
type Login struct {
// binding:"required"修饰的字段，若接收为空值，则报错，是必须字段
User string `form:"username" json:"user" uri:"user" xml:"user" binding:"required"`
Pssword string `form:"password" json:"password" uri:"password" xml:"password" binding:"required"`
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// 加载配置文件
r.LoadHTMLGlob("templates/*")
r.GET("/index", func(c *gin.Context) {
// 根据文件名渲染
// 最终json将title替换
c.HTML(200,"index.tmpl",gin.H{"title":"我的标题"})
})
r.Run()
}
index.tmpl
<html>
<h1>
{{ .title }}
</h1>
</html>
Example2
加载静态资源文件
gin_demo2.go
package main
import (
"fmt"
"github.com/gin-gonic/gin"
"net/http"
)
type Response struct {
Code int
Message string
Data interface{}
}
func main() {
r := gin.Default()
r.Static("/img","./img")
r.LoadHTMLGlob("./html/*")
r.GET("/html", func(c *gin.Context) {
fullPath := "请求路径" + c.FullPath()
c.HTML(http.StatusOK,"index.html",gin.H{
"fullPath":fullPath,
"title": "gin_student_demo",
})
fmt.Println(fullPath)
})
r.Run()
}
index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>{{ .title }}</title>
</head>
<body>
<h1>Gin Load HTML</h1>
{{ .fullPath }}
<div align="center"><img src="../img/1.png"></div>
</body>
</html>
重定向
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
r.GET("/index", func(c *gin.Context) {
// 支持内部和外部重定向
c.Redirect(http.StatusMovedPermanently,"http://www.baidu.com/")
})
r.Run()
}
同步异步
goroutine机制可以方便地实现异步处理
另外，在启动新的goroutine时，不应该使用原始上下文，必须使用它的只读副本
package main
import (
"github.com/gin-gonic/gin"
"log"
"time"
)
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// 1. 异步
r.GET("/long_async", func(c *gin.Context) {
// 需要搞一个副本
copyContext := c.Copy()
// 异步处理
go func() {
time.Sleep(3 * time.Second)
log.Println("异步执行:" + copyContext.Request.URL.Path)
}()
})
// 2. 同步
r.GET("/long_sync", func(c *gin.Context) {
time.Sleep(3 * time.Second)
log.Println("同步执行:" + c.Request.URL.Path)
})
r.Run()
}
Gin中间件
在web应用服务中，完整的一个业务处理在技术上包含客户端操作、服务器端处理、返回处理结果给客户端三个步骤。
在实际的业务开发和处理中，会有更负责的业务和需求场景。一个完整的系统可能要包含鉴权认证、权限管理、安全检查、日志记录等多维度的系统支持。
鉴权认证、权限管理、安全检查、日志记录等这些保障和支持系统业务属于全系统的业务，和具体的系统业务没有关联，对于系统中的所有业务都适用。
由此，在业务开发过程中，为了更好的梳理系统架构，可以将上述描述所涉及的一些通用业务单独抽离并进行开发，然后以插件化的形式进行对接。这种方式既保证了系统功能的完整，同时又有效的将具体业务和系统功能进行解耦，并且，还可以达到灵活配置的目的。
这种通用业务独立开发并灵活配置使用的组件，一般称之为"中间件"，因为其位于服务器和实际业务处理程序之间。其含义就是相当于在请求和具体的业务逻辑处理之间增加某些操作，这种以额外添加的方式不会影响编码效率，也不会侵入到框架中。中间件的位置和角色示意图如下图所示：
所有请求都经过中间件
gin可以构建中间件，但它只对注册过的路由函数起作用
对于分组路由，嵌套使用中间件，可以限定中间件的作用范围
中间件分为全局中间件，单个路由中间件和群组中间件
gin中间件必须是一个 gin.HandlerFunc 类型
/*
HandlerFunc 是一个函数类型, 接受一个Context参数,
用于编写程序处理函数并返回HandleFunc类型, 作为中间件的定义
*/
全局中间件
middleware.go
package main
import (
"fmt"
"github.com/gin-gonic/gin"
"time"
)
// 定义中间件
func MiddleWare() gin.HandlerFunc {
return func(c *gin.Context) {
t := time.Now()
fmt.Println("中间件开始执行了")
// 设置变量到Context的key中, 可以通过Get()取
c.Set("request","中间件")
// 执行函数
c.Next()
// 中间件执行完后续的一些事情
status := c.Writer.Status()
fmt.Println("中间件执行完毕",status)
t2 := time.Since(t)
fmt.Println("time:",t2)
}
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// 注册中间件
r.Use(MiddleWare())
// 为了代码规范
{
r.GET("/middleware", func(c *gin.Context) {
// 取值
req, _:=c.Get("request")
fmt.Println("request",req)
// 页面接受
c.JSON(200,gin.H{"request":req})
})
}
r.Run()
}
/*
curl localhost:8080/middleware
{"request":"中间件"}%
*/
局部中间件
package main
import (
"fmt"
"github.com/gin-gonic/gin"
"time"
)
// 定义中间件
func MiddleWare() gin.HandlerFunc {
return func(c *gin.Context) {
t := time.Now()
fmt.Println("中间件开始执行了")
// 设置变量到Context的key中, 可以通过Get()取
c.Set("request","中间件")
// 执行函数
c.Next()
// 中间件执行完后续的一些事情
status := c.Writer.Status()
fmt.Println("中间件执行完毕",status)
t2 := time.Since(t)
fmt.Println("time:",t2)
}
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// 注册中间件
r.Use(MiddleWare())
// 为了代码规范
{
r.GET("/middleware",MiddleWare(),func(c *gin.Context) {
// 取值
req, _:=c.Get("request")
fmt.Println("request",req)
// 页面接受
c.JSON(200,gin.H{"request":req})
})
}
r.Run()
}
自定义中间件
可以自己定义实现一个特殊需求的中间件，中间件的类型是函数，有两条标准：
func函数
返回值类型为HandlerFunc
比如，我们自定义一个自己的中间件。我们在处理请求时，为了方便代码调试，通常都将请求的一些信息打印出来。有了中间件以后，为了避免代码多次重复编写，使用统一的中间件来完成。定义一个名为RequestInfos的中间件，在该中间件中打印请求的path和method。具体代码实现如下所示：
Example1
func RequestInfos() gin.HandlerFunc {
return func(context *gin.Context) {
path := context.FullPath()
method := context.Request.Method
fmt.Println("请求Path：", path)
fmt.Println("请求Method：", method)
}
}
func main() {
engine := gin.Default()
engine.Use(RequestInfos())
engine.GET("/query", func(context *gin.Context) {
context.JSON(200, map[string]interface{}{
"code": 1,
"msg": context.FullPath(),
})
})
engine.Run(":9000")
}
Example2
package main
import (
"fmt"
"github.com/gin-gonic/gin"
"time"
)
// 定义中间
func myTime(c *gin.Context) {
start := time.Now()
c.Next()
// 统计时间
since := time.Since(start)
fmt.Println("程序耗时",since)
}
func main() {
// 1.创建路由
// 默认使用了2个中间件Logger(), Recovery()
r := gin.Default()
// 注册中间件
r.Use(myTime)
// {}为了代码规范
shoppingGroup := r.Group("/shopping")
{
shoppingGroup.GET("/index",shopIndexHandler)
shoppingGroup.GET("/home",shopHomeHandleer)
}
r.Run()
}
func shopIndexHandler(c *gin.Context) {
time.Sleep(5 * time.Second)
}
func shopHomeHandleer(c *gin.Context) {
time.Sleep(5 * time.Second)
}
Gin日志
为什么要使用日志
/*
记录参数信息
猜测用户行为
复现系统bug并修复
*/
Gin自带日志写入中间件
// 自定义日志比较麻烦
第三方日志工具
/*
go-logginng
logrus
*/
go-logger_Example
日志切割
/*
自行根据时间在写入时判断进行切割日志
借助成品的日志包: go-file-rotatelogs file-rotatelogs
*/