Web框架之Gin

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

Gin框架介紹

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

Gin框架安裝與使用

安裝

下載並安裝Gin:github

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字符串。web

RESTful API

REST與技術無關，表明的是一種軟件架構風格，REST是Representational State Transfer的簡稱，中文翻譯爲「表徵狀態轉移」或「表現層狀態轉化」。json

推薦閱讀阮一峯理解RESTful架構後端

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

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設計以下：restful

請求方法	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) {...})

路由組

咱們能夠將擁有共同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這個庫。

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

Gin框架介紹及使用