Gin框架介紹及使用

本文轉載自查看原文 2021-08-19 17:25 96 web/ go/ http/ gin

Gin框架介紹

基於httprouter開發的Web框架。
中文文檔，齊全。
簡單易用的輕量級框架。

Gin框架安裝

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

實例:

package main
import (
	"fmt"
	"github.com/gin-gonic/gin"
)
func main() {

	r := gin.Default()
	// 創建一個默認的路由引擎
	// 也可以用gin.New() gin.Default()多用了日志和panic的recover中間件
	r.GET("/helloworld", func(c *gin.Context) {
		c.JSON(200, gin.H{
			// c.JSON：返回JSON格式的數據
			"msg": "Hello world!",
		})
	})
	err := r.Run("127.0.0.1:8001")
	// 啟動HTTP服務，默認在127.0.0.1:8001啟動服務
	if err != nil {
		fmt.Println("run gin field")
		return
	}
}

RESTful API

REST與技術無關，代表的是一種軟件架構風格，REST是Representational State Transfer的簡稱，中文翻譯為“表征狀態轉移”或“表現層狀態轉化”。

簡單來說，REST的含義就是客戶端與Web服務器之間進行交互的時候，使用HTTP協議中的4個請求方法代表不同的動作。

GET用來獲取資源
POST用來新建資源
PUT用來更新資源
DELETE用來刪除資源。

只要API程序遵循了REST風格，那就可以稱其為RESTful API。目前在前后端分離的架構中，前后端基本都是通過RESTful API來進行交互。

例如，我們現在要編寫一個管理書籍的系統，我們可以查詢對一本書進行查詢、創建、更新和刪除等操作，我們在編寫程序的時候就要設計客戶端瀏覽器與我們Web服務端交互的方式和路徑。按照經驗我們通常會設計成如下模式：

請求方法	URL	含義
GET	/book	查詢書籍信息
POST	/create_book	創建書籍記錄
POST	/update_book	更新書籍信息
POST	/delete_book	刪除書籍信息

同樣的需求我們按照RESTful API設計如下：

請求方法	URL	含義
GET	/book	查詢書籍信息
POST	/book	創建書籍記錄
PUT	/book	更新書籍信息
DELETE	/book	刪除書籍信息

Gin框架支持開發RESTful API的開發。

func main() {
	r := gin.Default()
	r.GET("/book", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "GET",
		})
	})
	r.POST("/book", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "POST",
		})
	})
	r.PUT("/book", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "PUT",
		})
	})
	r.DELETE("/book", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "DELETE",
		})
	})
}

開發RESTful API的時候我們通常使用Postman來作為客戶端的測試工具。

Gin渲染

HTML渲染

我們首先定義一個存放模板文件的templates文件夾，然后在其內部按照業務分別定義一個posts文件夾和一個users文件夾。posts/index.html文件的內容如下：

{{define "posts/index.html"}}
    posts/index
    {{.title}}
{{end}}

users/index.html文件的內容如下：

{{define "users/index.html"}}
    users/index
    {{.title}}
{{end}}

Gin框架中使用LoadHTMLGlob()或者LoadHTMLFiles()方法進行HTML模板渲染。

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("templates/**/*")
	//r.LoadHTMLFiles("templates/posts/index.html", "templates/users/index.html")
	r.GET("/posts/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "posts/index.html", gin.H{
			"title": "posts/index",
		})
	})
	r.GET("users/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "users/index.html", gin.H{
			"title": "users/index",
		})
	})
	r.Run(":8080")
}

靜態文件處理

當我們渲染的HTML文件中引用了靜態文件時，我們只需要按照以下方式在渲染頁面前調用gin.Static方法即可。

func main() {
	r := gin.Default()
	r.Static("/static", "./static")
	r.LoadHTMLGlob("templates/**/*")
   ...
	r.Run(":8080")
}

補充文件路徑處理

關於模板文件和靜態文件的路徑，我們需要根據公司/項目的要求進行設置。可以使用下面的函數獲取當前執行程序的路徑。

func getCurrentPath() string {
	if ex, err := os.Executable(); err == nil {
		return filepath.Dir(ex)
	}
	return "./"
}

JSON渲染

func main() {
	r := gin.Default()
	// gin.H 是map[string]interface{}的縮寫
	r.GET("/someJSON", func(c *gin.Context) {
		// 方式一：自己拼接JSON
		c.JSON(http.StatusOK, gin.H{"message": "Hello world!"})
	})
	r.GET("/moreJSON", func(c *gin.Context) {
		// 方法二：使用結構體
		var msg struct {
			Name    string `json:"user"`
			Message string
			Age     int
		}
		msg.Name = "zhy"
		msg.Message = "Hello world!"
		msg.Age = 18
		c.JSON(http.StatusOK, msg)
	})
	r.Run(":8080")
}

XML渲染

注意需要使用具名的結構體類型。

func main() {
	r := gin.Default()
	// gin.H 是map[string]interface{}的縮寫
	r.GET("/someXML", func(c *gin.Context) {
		// 方式一：自己拼接JSON
		c.XML(http.StatusOK, gin.H{"message": "Hello world!"})
	})
	r.GET("/moreXML", func(c *gin.Context) {
		// 方法二：使用結構體
		type MessageRecord struct {
			Name    string
			Message string
			Age     int
		}
		var msg MessageRecord
		msg.Name = "小王子"
		msg.Message = "Hello world!"
		msg.Age = 18
		c.XML(http.StatusOK, msg)
	})
	r.Run(":8080")
}

YMAL渲染

r.GET("/someYAML", func(c *gin.Context) {
	c.YAML(http.StatusOK, gin.H{"message": "ok", "status": http.StatusOK})
})

protobuf渲染

// protobuf文件
syntax = "proto3";
package models;
message hello {
    string content = 1;
}

package main
import (
	"net/http"
	"test/models"
	"github.com/gin-gonic/gin"
)
func main() {
	r := gin.Default()
	r.GET("/hello",func (c *gin.Context)  {
		res := &models.Hello{
			Content: "你好",
		}
		c.ProtoBuf(http.StatusOK,res)
	})
	_ = r.Run("127.0.0.1:8001")
}

獲取參數

獲取querystring參數

querystring指的是URL中?后面攜帶的參數，例如：/user?username=趙海宇&address=地球一角。

c.DefaultQuery有默認值如果沒有傳去默認值
c.Query沒有默認值如果沒傳為空

package main
import (
	"net/http"
	"github.com/gin-gonic/gin"
)
func main() {
	r := gin.Default()
	r.GET("/user", func(c *gin.Context) {
		username := c.DefaultQuery("username", "zhy")
		address := c.Query("address")
		c.JSON(http.StatusOK, gin.H{
			"username": username,
			"address":  address,
		})
	})
	_ = r.Run("127.0.0.1:8001")
}

獲取form參數

請求的數據通過form表單來提交，例如向/user發送一個POST請求，獲取請求數據的方式如下：c.PostForm

package main
import (
	"net/http"
	"github.com/gin-gonic/gin"
)
func main() {
	r := gin.Default()
	r.POST("/user", func(c *gin.Context) {
		username := c.PostForm("username")
		address := c.PostForm("address")
		c.JSON(http.StatusOK, gin.H{
			"username": username,
			"address":  address,
		})
	})
	_ = r.Run("127.0.0.1:8001")
}

獲取path參數

請求的參數通過URL路徑傳遞，例如：/user/zhaohaiyu/地球一角/路由:/user/:username/:address方法:c.Param

package main
import (
	"net/http"
	"github.com/gin-gonic/gin"
)
func main() {
	r := gin.Default()
	r.GET("/user/:username/:address", func(c *gin.Context) {
		username := c.Param("username")
		address := c.Param("address")
		c.JSON(http.StatusOK, gin.H{
			"username": username,
			"address":  address,
		})
	})
	_ = r.Run("127.0.0.1:8001")
}

參數綁定

為了能夠更方便的獲取請求相關參數，提高開發效率，我們可以基於請求的content-type識別請求數據類型並利用反射機制自動提取請求中querystring、form表單、JSON、XML等參數到結構體中。

package main
import (
	"fmt"
	"net/http"
	"github.com/gin-gonic/gin"
)
// Binding from JSON
type Login struct {
	User     string `form:"user" json:"user" binding:"required"`
	Password string `form:"password" json:"password" binding:"required"`
}
func main() {
	r := gin.Default()
	// 綁定JSON的示例 ({"user": "root", "password": "123"})
	r.POST("/loginJSON", func(c *gin.Context) {
		var login Login
		if err := c.ShouldBindJSON(&login); err == nil {
			fmt.Printf("login info:%#v\n", login)
			c.JSON(http.StatusOK, login)
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})
	// 綁定form表單示例 (user=root&password=123)
	r.POST("/loginForm", func(c *gin.Context) {
		var login Login
		// ShouldBind()會根據請求的Content-Type自行選擇綁定器
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, login)
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})
	// 綁定querystring示例 (user=root&password=123)
	r.GET("/loginForm", func(c *gin.Context) {
		var login Login
		// ShouldBind()會根據請求的Content-Type自行選擇綁定器
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, login)
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})
	_ = r.Run("127.0.0.1:8001")
}

文件上傳

func main() {
	router := gin.Default() // 處理multipart forms提交文件時默認的內存限制是32 MiB
	// 可以通過下面的方式修改
	// router.MaxMultipartMemory = 8 << 20 // 8 MiB
	router.POST("/upload", func(c *gin.Context) {
		// 單個文件
		file, err := c.FormFile("file")
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"message": err.Error()})
			return
		}
		log.Println(file.Filename)
		dst := fmt.Sprintf("C:/tmp/%s", file.Filename) // 上傳文件到指定的目錄
		c.SaveUploadedFile(file, dst)
		c.JSON(http.StatusOK, gin.H{"message": fmt.Sprintf("'%s' uploaded!", file.Filename)})
	})
	router.Run()
}

多個文件上傳

func main() {
	router := gin.Default()
	// 處理multipart forms提交文件時默認的內存限制是32 MiB
	// 可以通過下面的方式修改
	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
	router.POST("/upload", func(c *gin.Context) {
		// Multipart form
		form, _ := c.MultipartForm()
		files := form.File["file"]
		for index, file := range files {
			log.Println(file.Filename)
			dst := fmt.Sprintf("C:/tmp/%s_%d", file.Filename, index)
			// 上傳文件到指定的目錄
			c.SaveUploadedFile(file, dst)
		}
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("%d files uploaded!", len(files)),
		})
	})
	router.Run()
}

Gin中間件

Gin框架允許開發者在處理請求的過程中，加入用戶自己的鈎子（Hook）函數。這個鈎子函數就叫中間件，中間件適合處理一些公共的業務邏輯，比如登錄校驗、日志打印、耗時統計等。

Gin中的中間件必須是一個gin.HandlerFunc類型。例如我們像下面的代碼一樣定義一個中間件。

// StatCost 是一個統計耗時請求耗時的中間件
func StatCost() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		c.Set("name", "小王子")
		// 執行其他中間件
		c.Next()
		// 計算耗時
		cost := time.S***art)
		log.Println(cost)
	}
}

然后注冊中間件的時候，可以在全局注冊。

func main() {
	// 新建一個沒有任何默認中間件的路由
	r := gin.New()
	// 注冊一個全局中間件
	r.Use(StatCost())

	r.GET("/test", func(c *gin.Context) {
		name := c.MustGet("name").(string)
		log.Println(name)
		c.JSON(http.StatusOK, gin.H{
			"message": "Hello world!",
		})
	})
	r.Run()
}

也可以給某個路由單獨注冊中間件。

// 給/test2路由單獨注冊中間件（可注冊多個）
	r.GET("/test2", StatCost(), func(c *gin.Context) {
		name := c.MustGet("name").(string)
		log.Println(name)
		c.JSON(http.StatusOK, gin.H{
			"message": "Hello world!",
		})
	})

重定向

HTTP重定向

HTTP 重定向很容易。內部、外部重定向均支持。

r.GET("/test", func(c *gin.Context) {
	c.Redirect(http.StatusMovedPermanently, "http://www.google.com/")
})

路由重定向

路由重定向，使用HandleContext：

r.GET("/test", func(c *gin.Context) {
    // 指定重定向的URL
    c.Request.URL.Path = "/test2"
    r.HandleContext(c)
})
r.GET("/test2", func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"hello": "world"})
})

Gin路由

普通路由

r.GET("/index", func(c *gin.Context) {...})
r.GET("/login", func(c *gin.Context) {...})
r.POST("/login", func(c *gin.Context) {...})

此外，還有一個可以匹配所有請求方法的Any方法如下：

r.Any("/test", func(c *gin.Context) {...})

為沒有配置處理函數的路由添加處理程序。默認情況下它返回404代碼。

r.NoRoute(func(c *gin.Context) {
		c.HTML(http.StatusNotFound, "views/404.html", nil)
	})

路由組

我們可以將擁有共同URL前綴的路由划分為一個路由組。

func main() {
	r := gin.Default()
	userGroup := r.Group("/user")
	{
		userGroup.GET("/index", func(c *gin.Context) {...})
		userGroup.GET("/login", func(c *gin.Context) {...})
		userGroup.POST("/login", func(c *gin.Context) {...})
	}
	shopGroup := r.Group("/shop")
	{
		shopGroup.GET("/index", func(c *gin.Context) {...})
		shopGroup.GET("/cart", func(c *gin.Context) {...})
		shopGroup.POST("/checkout", func(c *gin.Context) {...})
	}
	r.Run()
}

通常我們將路由分組用在划分業務邏輯或划分API版本時。

路由分文件

在route中初始化route和切片路由組
在各個文件寫路由
在main中把路由函數放入函數路由組

// route中go
package route
import "github.com/gin-gonic/gin"
type Option func(*gin.Engine)
var options = []Option{} // 路由函數組
// 注冊app的路由配置
func Include(opts ...Option) {
	options = append(options, opts...) // 路由函數組添加函數
}
// 初始化
func Init() *gin.Engine {
	r := gin.New()
	for _, function := range options {
		function(r) // 執行路由函數組中所有函數
	}
	return r
}

// shop中的文件
package shop
import "github.com/gin-gonic/gin"
func Routers(e *gin.Engine) {// 路由函數
	e.GET("/post", func(c *gin.Context) {
		c.String(200,"psot shop")
	})
	e.GET("/comment", func(c *gin.Context) {
		c.String(200,"comment shop")
	})
}

// main.go
package main
import (
	"test/demo1/route"
	"test/demo1/shop"
)
func main() {
	route.Include(shop.Routers)
	// 初始化路由
	r := route.Init() 
	_ = r.Run()
}

路由原理

Gin框架中的路由使用的是httprouter這個庫。

其基本原理就是構造一個路由地址的前綴樹。

參考文章

https://www.liwenzhou.com/posts/Go/Gin_framework/

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Gin框架介紹及使用 Gin框架介紹與使用 Gin框架介紹及使用 Gin框架介紹及使用 Gin框架介紹及使用一.Gin框架介紹與基本使用 gin框架教程一: go框架gin的基本使用 gin 框架的使用 Gin框架使用詳解基於gin框架的session使用