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

时间：2024-01-27 15:29:52

数据解析和绑定

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格式解析到结构体
		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"}%     
*/

​

表单数据解析和绑定

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"`
}

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()
}
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>

重定向

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中间件

所有请求都经过中间件

gin可以构建中间件，但它只对注册过的路由函数起作用

对于分组路由，嵌套使用中间件，可以限定中间件的作用范围

中间件分为全局中间件，单个路由中间件和群组中间件

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

全局中间件

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()
}

Example1

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)
}

相关文章