數據解析和綁定
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
*/