02 . Go框架之Gin框架从入门到熟悉(数据解析和绑定,渲染,重定向,同步异步,中间件)

数据解析和绑定

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
*/

相关阅读:
程序员过年必备 -- Auto.js微信自动抢红包
 VSCode, Django, and Anaconda开发环境集成配置[Windows]
pandas to_excel 修改excel样式以及格式
 hvac系统开源项目情况匠能智控
 安卓作业（有空再整理）
在jetson nano中配opencv环境（python通用）
获取深度图像
 英伟达开发板安装python-opencv下的问题
 在vs2015中对kinectV2环境搭建，环境配置
 PagerSlidingTabStrip 导入 Android Studio 的教程
原文地址：https://www.cnblogs.com/you-men/p/13896792.html