Gin框架介紹及使用

本文轉載自查看原文 2019-10-26 11:14 849 Go基礎

Gin框架介紹及使用

Gin是一個用Go語言編寫的web框架。它是一個類似於martini但擁有更好性能的API框架, 由於使用了httprouter，速度提高了近40倍。如果你是性能和高效的追求者, 你會愛上Gin。

Gin框架介紹

Go世界里最流行的Web框架，Github上有24K+star。基於httprouter開發的Web框架。中文文檔齊全，簡單易用的輕量級框架。

Gin框架安裝與使用

安裝

下載並安裝Gin:

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

第一個Gin示例：

package main

import (
	"github.com/gin-gonic/gin"
)

func main() {
	// 創建一個默認的路由引擎
	r := gin.Default()
	// GET：請求方式；/hello：請求的路徑
	// 當客戶端以GET方法請求/hello路徑時，會執行后面的匿名函數
	r.GET("/hello", func(c *gin.Context) {
		// c.JSON：返回JSON格式的數據
		c.JSON(200, gin.H{
			"message": "Hello world!",
		})
	})
	// 啟動HTTP服務，默認在0.0.0.0:8080啟動服務
	r.Run()
}

將上面的代碼保存並編譯執行，然后使用瀏覽器打開127.0.0.1:8080/hello就能看到一串JSON字符串。

RESTful API

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

推薦閱讀阮一峰理解RESTful架構

簡單來說，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"}}
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>posts/index</title>
</head>
<body>

    {{.title}}

</body>
</html>
{{end}}

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

{{define "users/index.html"}}
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>users/index</title>
</head>

<body>
    {{.title}}
</body>
</html>
{{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 = "小王子"
		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渲染

r.GET("/someProtoBuf", func(c *gin.Context) {
	reps := []int64{int64(1), int64(2)}
	label := "test"
	// protobuf 的具體定義寫在 testdata/protoexample 文件中。
	data := &protoexample.Test{
		Label: &label,
		Reps:  reps,
	}
	// 請注意，數據在響應中變為二進制數據
	// 將輸出被 protoexample.Test protobuf 序列化了的數據
	c.ProtoBuf(http.StatusOK, data)
})

獲取參數

獲取querystring參數

querystring指的是URL中?后面攜帶的參數，例如：/user/search?username=小王子&address=沙河。獲取請求的querystring參數的方法如下：

func main() {
	//Default返回一個默認的路由引擎
	r := gin.Default()
	r.GET("/user/search", func(c *gin.Context) {
		username := c.DefaultQuery("username", "小王子")
		//username := c.Query("username")
		address := c.Query("address")
		//輸出json結果給調用方
		c.JSON(http.StatusOK, gin.H{
			"message":  "ok",
			"username": username,
			"address":  address,
		})
	})

	r.Run()
}

獲取form參數

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

func main() {
	//Default返回一個默認的路由引擎
	r := gin.Default()
	r.POST("/user/search", func(c *gin.Context) {
		// DefaultPostForm取不到值時會返回指定的默認值
		//username := c.DefaultPostForm("username", "小王子")
		username := c.PostForm("username")
		address := c.PostForm("address")
		//輸出json結果給調用方
		c.JSON(http.StatusOK, gin.H{
			"message":  "ok",
			"username": username,
			"address":  address,
		})
	})
	r.Run(":8080")
}

獲取path參數

請求的參數通過URL路徑傳遞，例如：/user/search/小王子/沙河。獲取請求URL路徑中的參數的方式如下。

func main() {
	//Default返回一個默認的路由引擎
	r := gin.Default()
	r.GET("/user/search/:username/:address", func(c *gin.Context) {
		username := c.Param("username")
		address := c.Param("address")
		//輸出json結果給調用方
		c.JSON(http.StatusOK, gin.H{
			"message":  "ok",
			"username": username,
			"address":  address,
		})
	})

	r.Run(":8080")
}

參數綁定

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

// Binding from JSON
type Login struct {
	User     string `form:"user" json:"user" binding:"required"`
	Password string `form:"password" json:"password" binding:"required"`
}

func main() {
	router := gin.Default()

	// 綁定JSON的示例 ({"user": "q1mi", "password": "123456"})
	router.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, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})

	// 綁定form表單示例 (user=q1mi&password=123456)
	router.POST("/loginForm", func(c *gin.Context) {
		var login Login
		// ShouldBind()會根據請求的Content-Type自行選擇綁定器
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})

	// 綁定querystring示例 (user=q1mi&password=123456)
	router.GET("/loginForm", func(c *gin.Context) {
		var login Login
		// ShouldBind()會根據請求的Content-Type自行選擇綁定器
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})

	// Listen and serve on 0.0.0.0:8080
	router.Run(":8080")
}

文件上傳

單個文件上傳

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.Since(start)
		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版本時。

路由原理

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

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

免責聲明！

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

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