18-Gin开发

Gin是一个用Go语言编写的web框架。它是一个类似于martini但拥有更好性能的API框架, 由于使用了httprouter，速度提高了近40倍。如果你是性能和高效的追求者, 你会爱上Gin。

Gin框架介绍

Go世界里最流行的Web框架，Github上有32K+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()
}

访问

http://127.0.0.1:8080/hello

如今web开发，基本不会纯后端，以template模式开发，主流都是前后端分离模式。

前端只管提供页面交互、后端只管提供API、最后运维以nginx部署。

若是微服务开发，以grpc协议，以pb数据格式传递。

合格的开发是能快速以对应技术，解决需求。

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

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模板渲染。

package main

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

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",
            "name":  "于超get--posts/index",
        })
    })

    r.GET("users/index", func(c *gin.Context) {
        c.HTML(http.StatusOK, "users/index.html", gin.H{
            "title": "users/index",
            "name":  "于超get--users/index",
        })
    })

    r.Run(":8080")
}

自定义模板函数

定义一个不转义相应内容的safe模板函数如下：

package main

import (
    "github.com/gin-gonic/gin"
    "html/template"
    "net/http"
)

func main() {
    router := gin.Default()
    //定义不转义的模板，正常加载html语法
    router.SetFuncMap(template.FuncMap{
        "safe": func(str string) template.HTML {
            return template.HTML(str)
        },
    })
    router.LoadHTMLFiles("./index.tmpl")

    router.GET("/index", func(c *gin.Context) {
        c.HTML(http.StatusOK, "index.tmpl", "<a href='http://yuchaoit.cn'>超哥带你学linux</a>")
    })

    router.Run(":8080")
}

静态文件处理

当我们渲染的HTML文件中引用了静态文件时，我们只需要按照以下方式在渲染页面前调用gin.Static方法即可。

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

使用模板继承

Gin框架默认都是使用单模板，如果需要使用block template功能，可以通过"github.com/gin-contrib/multitemplate"库实现，具体示例如下：

首先，假设我们项目目录下的templates文件夹下有以下模板文件，其中home.tmpl和index.tmpl继承了base.tmpl：

templates
├── includes
│   ├── home.tmpl
│   └── index.tmpl
├── layouts
│   └── base.tmpl
└── scripts.tmpl

然后我们定义一个loadTemplates函数如下：

func loadTemplates(templatesDir string) multitemplate.Renderer {
    r := multitemplate.NewRenderer()
    layouts, err := filepath.Glob(templatesDir + "/layouts/*.tmpl")
    if err != nil {
        panic(err.Error())
    }
    includes, err := filepath.Glob(templatesDir + "/includes/*.tmpl")
    if err != nil {
        panic(err.Error())
    }
    // 为layouts/和includes/目录生成 templates map
    for _, include := range includes {
        layoutCopy := make([]string, len(layouts))
        copy(layoutCopy, layouts)
        files := append(layoutCopy, include)
        r.AddFromFiles(filepath.Base(include), files...)
    }
    return r
}

我们在main函数中

func indexFunc(c *gin.Context){
    c.HTML(http.StatusOK, "index.tmpl", nil)
}

func homeFunc(c *gin.Context){
    c.HTML(http.StatusOK, "home.tmpl", nil)
}

func main(){
    r := gin.Default()
    r.HTMLRender = loadTemplates("./templates")
    r.GET("/index", indexFunc)
    r.GET("/home", homeFunc)
    r.Run()
}

补充文件路径处理

关于模板文件和静态文件的路径，我们需要根据公司/项目的要求进行设置。可以使用下面的函数获取当前执行程序的路径。

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

r.Any()

package main

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

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

    // gin.H 是map[string]interface{}的缩写
    r.GET("/hello", func(c *gin.Context) {
        // 方式一：自己拼接JSON，调用gin.H{}
        c.JSON(http.StatusOK, gin.H{"message": "Hello world!"})
    })

    r.GET("/hello2", func(c *gin.Context) {
        // 方法二：使用结构体
        //返回指定的结构体，可以指定json字段
        var msg struct {
            Name    string `json:"user"`
            Message string
            Age     int
        }
        msg.Name = "小于超"
        msg.Message = "Hello world!"
        msg.Age = 28
        c.JSON(http.StatusOK, msg)
    })

    //调用通用方法
    r.Any("/any", func(c *gin.Context) {
        switch c.Request.Method {
        case http.MethodGet:
            c.String(200, "恭喜你，get成功。")
        case http.MethodPost:
            c.String(200, "恭喜你，post成功。")
        default:
            c.String(500, "错误！！必须传入get，post")
        }
    })

    r.Run(":8080")

}

/*
➜  ~ curl 127.0.0.1:8080/hello
{"message":"Hello world!"}
➜  ~
➜  ~ curl 127.0.0.1:8080/hello2
{"user":"小于超","Message":"Hello world!","Age":28}
➜  ~
*/

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参数的方法如下：

package main

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

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参数

urlencode编码格式

当前端请求的数据通过form表单提交时，例如向/user/search发送一个POST请求，获取请求数据的方式如下：

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    //Default返回一个默认的路由引擎
    r := gin.Default()
    r.POST("/user/search", func(c *gin.Context) {
        fmt.Println("用户请求url：", c.Request.URL)
        // 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")
}

获取json参数

当前端请求的数据通过JSON提交时，例如向/json发送一个POST请求，则获取请求参数的方式如下：

r.POST("/json", func(c *gin.Context) {
    // 注意：下面为了举例子方便，暂时忽略了错误处理
    b, _ := c.GetRawData()  // 从c.Request.Body读取请求数据
    // 定义map或结构体
    var m map[string]interface{}
    // 反序列化
    _ = json.Unmarshal(b, &m)

    c.JSON(http.StatusOK, m)
})

获取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等参数到结构体中。

下面的示例代码演示了.ShouldBind()强大的功能，它能够基于请求自动提取JSON、form表单和QueryString类型的数据，并把值绑定到指定的结构体对象。

c.ShouldBind方法

struct注意点

tag要对应
传入*struct
首字母大写

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

// Binding from JSON
// 结构体库，内置的binding字段提供校验功能，限制改字段必须有
// 还可以单独使用验证器 validater
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": "yuchao", "password": "123456"})
    router.POST("/loginJSON", func(c *gin.Context) {
        var login Login

        if err := c.ShouldBind(&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 c.String 表示返回具体数据类型
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        }
    })

    // 绑定form表单示例 (user=yuchao&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示例 (/loginQuery?user=yuchao&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()})
        }

        //还可以继续处理，并没有return，上述c.JSON 已经写入响应内容，写入ctx，内部有return，类似其他语言的render
        //一般表示最后一步的处理
        //但还可以继续处理

    })

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

/*
http://127.0.0.1:8080/loginForm
{
"password": "yu123",
"user": "于超"
}


*/

c.ShouldBind源码

基于content-type判断

ShouldBind会按照下面的顺序解析请求中的数据完成绑定：

如果是 GET 请求，只使用 Form 绑定引擎（query）。
如果是 POST 请求，首先检查 content-type 是否为 JSON 或 XML，然后再使用 Form（form-data）。

文件上传

单个文件上传

文件上传前端页面代码，前端form表单

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <title>上传文件示例</title>
</head>
<body>
<form action="/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="myself">
    <input type="submit" value="上传">
</form>
</body>
</html>

后端gin框架部分代码，对应表单提交接口

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "log"
    "net/http"
)

func main() {
    router := gin.Default()
    // 处理multipart forms提交文件时默认的内存限制是32 MiB
    // 可以通过下面的方式修改
    // router.MaxMultipartMemory = 8 << 20  // 8 MiB

    //文件上传页面，用户访问
    router.LoadHTMLFiles("./templates/upload.html")
    router.GET("/uploadHTML", func(c *gin.Context) {
        c.HTML(http.StatusOK, "upload.html", nil)
    })

    //submit 提交post请求，接收请求处理

    router.POST("/upload", func(c *gin.Context) {
        // 单个文件
        //获取前端单个文件名,和前端开发约定好的名字
        file, err := c.FormFile("myself")
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "message": err.Error(),
            })
            return
        }

        log.Println(file.Filename)

        //设置文件存储格式，路径，保存结构体信息
        dst := fmt.Sprintf("./saveFile/%s", file.Filename)

        // 上传文件到指定的目录，传入单个文件对象，到目标路径
        err = c.SaveUploadedFile(file, dst)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "message": err.Error(),
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "message": fmt.Sprintf("'%s' uploaded!", file.Filename),
        })
    })
    router.Run()
}

run和build的区别

代码中涉及文件路径操作时，建议go build写入路径，再运行
不建议 go run 因为去tmp目录编译，可能出错

多个文件上传

html

传入multiple表示多个文件

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <title>上传文件示例</title>
</head>
<body>
<form action="/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="myself" multiple/>
    <input type="submit" value="上传">
</form>
</body>
</html>

后端

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "log"
    "net/http"
)

func main() {
    router := gin.Default()
    // 处理multipart forms提交文件时默认的内存限制是32 MiB
    // 可以通过下面的方式修改
    // router.MaxMultipartMemory = 8 << 20  // 8 MiB

    //文件上传页面，用户访问
    router.LoadHTMLFiles("./templates/upload.html")
    router.GET("/uploadHTML", func(c *gin.Context) {
        c.HTML(http.StatusOK, "upload.html", nil)
    })

    //多个文件上传
    // 处理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["myself"] // 获取前端文件名
        //循环处理每一个文件
        for index, file := range files {
            log.Println(file.Filename)
            dst := fmt.Sprintf("./saveFile/%s_%d", file.Filename, index)
            // 上传文件到指定的目录，或者第三方的oss
            c.SaveUploadedFile(file, dst)
        }
        c.JSON(http.StatusOK, gin.H{
            "message": fmt.Sprintf("%d files uploaded!", len(files)),
        })
    })

    router.Run()
}

重定向

HTTP重定向

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

路由重定向

路由重定向，使用HandleContext

package main

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

func main() {
    r := gin.Default()
    // http 301跳转
    r.GET("/test", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "http://www.yuchaoit.cn/")
    })

    //路由重定向，apiA  > apiB处理
    r.GET("/t1", func(c *gin.Context) {
        // 指定重定向的URL
        c.Request.URL.Path = "/t2"
        r.HandleContext(c)
    })
    r.GET("/t2", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"hello": "t2"})
    })

    r.Run()
}

处理gin.Context数据

当你gin中多个函数要处理ctx上下文数据，如

解析参数，校验参数
获取数据，拼接业务数据
返回数据

package main

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

func getStuData() gin.H {
    return gin.H{
        "name": "于抄抄",
    }
}

func stuHandler(c *gin.Context) {
    data := getStuData()
    c.JSON(http.StatusOK, data)
}

func schoolHandler(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "school": "超神学院",
        "stu":    getStuData(),
    })
}

func main() {
    r := gin.Default()
    // http 301跳转
    r.GET("/test", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "http://www.yuchaoit.cn/")
    })

    //路由重定向，apiA  > apiB处理
    r.GET("/t1", func(c *gin.Context) {
        // 指定重定向的URL
        c.Request.URL.Path = "/t2"
        r.HandleContext(c)
    })
    r.GET("/t2", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"hello": "t2"})
    })

    //学生，学校接口
    r.GET("/stu", RunCost("2006-01-02"), stuHandler)
    r.GET("/school", schoolHandler)
    //默认路由处理，防止404
    r.NoRoute(func(c *gin.Context) {
        c.String(http.StatusNotFound, "该页面禁止访问")
    })

    r.Run(":7777")
}

middle.go

package main

import (
    "fmt"
    "log"
    "time"

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

// StatCost 是一个统计耗时请求耗时的中间件
func RunCost(format string) gin.HandlerFunc {
    return func(c *gin.Context) {
        if c.Request.URL.Path == "/xyz" {
            c.Next() // -> c.Abort()
            return
        }

        start := time.Now()
        fmt.Println(start.Format(format))
        // 可以通过c.Set在请求上下文中设置值，后续的处理函数能够取到该值
        c.Set("name", "小渔村")
        // 调用该请求的剩余处理程序
        c.Next()

        // 计算耗时
        cost := time.Since(start)
        log.Println("接口耗时：", cost)
    }
}

运行

➜  goStudy go run demo.go middle.go

Gin路由

普通路由

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

r.Any()

此外，还有一个可以匹配所有请求方法的Any方法如下：

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

r.NoRoute()

为没有配置处理函数的路由添加处理程序，默认情况下它返回404代码，下面的代码为没有匹配到路由的请求都返回views/404.html页面。

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

404路由处理

package main

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

func getStuData() gin.H {
    return gin.H{
        "name": "于抄抄",
    }
}

func stuHandler(c *gin.Context) {
    data := getStuData()
    c.JSON(http.StatusOK, data)
}

func schoolHandler(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "school": "超神学院",
        "stu":    getStuData(),
    })
}

func main() {
    r := gin.Default()
    // http 301跳转
    r.GET("/test", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "http://www.yuchaoit.cn/")
    })

    //路由重定向，apiA  > apiB处理
    r.GET("/t1", func(c *gin.Context) {
        // 指定重定向的URL
        c.Request.URL.Path = "/t2"
        r.HandleContext(c)
    })
    r.GET("/t2", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"hello": "t2"})
    })

    //学生，学校接口
    r.GET("/stu", RunCost("2006-01-02"), stuHandler)
    r.GET("/school", schoolHandler)
    //默认路由处理，防止404
    r.NoRoute(func(c *gin.Context) {
        c.String(http.StatusNotFound, "该页面禁止访问")
    })

    r.Run(":7777")
}

结果

➜  ~ curl http://127.0.0.1:7777/stus
该页面禁止访问

路由组

我们可以将拥有共同URL前缀的路由划分为一个路由组。

类似于namespace路由组的概念。

习惯性一对{}包裹同组的路由，这只是为了看着清晰，你用不用{}包裹功能上没什么区别。

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

路由组也是支持嵌套的，例如：

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) {...})
        // 嵌套路由组
        xx := shopGroup.Group("xx")
        xx.GET("/oo", func(c *gin.Context) {...})
    }

通常我们将路由分组用在划分业务逻辑或划分API版本时。

路由原理

Gin框架中的路由使用的是httprouter这个库。

其基本原理就是构造一个路由地址的前缀树。

Gin中间件

例如每一个接口，添加一个鉴权，封装中间件。

Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（Hook）函数。

这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等。

定义中间件

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

记录接口耗时的中间件

例如我们像下面的代码一样定义一个统计请求耗时的中间件，返回gin函数对象。

middle.go

package main

import (
    "fmt"
    "log"
    "time"

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

//    RunCost 是一个统计耗时请求耗时的中间件
//
// 也可以加入参数，实现闭包处理
//返回的func，使用了不属于函数内的，外层函数的format变量，实现闭包

func RunCost(format string) gin.HandlerFunc {
    return func(c *gin.Context) {
        if c.Request.URL.Path == "/xyz" {
            c.Next() // -> c.Abort()
            return
        }

        start := time.Now()
        fmt.Println(start.Format(format))
        // 可以通过c.Set在请求上下文中设置值，后续的处理函数能够取到该值
        c.Set("name", "小渔村")
        // 调用该请求的剩余处理程序
        //请求apiA后 > middle
        //    r.GET("/stu", RunCost("2006-01-02"), stuHandler)  ，走完中间件，然后走stuHandler
        //中间件结束后，继续执行stuHandler
        c.Next()

        //禁止向后执行，后面的stuHandler 不执行了
        //c.Abort()

        // 计算耗时
        cost := time.Since(start)
        log.Println("接口耗时：", cost)
    }
}

demo.go

package main

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

func getStuData() gin.H {
    return gin.H{
        "name": "于抄抄",
    }
}

func stuHandler(c *gin.Context) {
    data := getStuData()
    c.JSON(http.StatusOK, data)
}

func schoolHandler(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "school": "超神学院",
        "stu":    getStuData(),
    })
}

func main() {
    r := gin.Default()
    // http 301跳转
    r.GET("/test", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "http://www.yuchaoit.cn/")
    })

    //路由重定向，apiA  > apiB处理
    r.GET("/t1", func(c *gin.Context) {
        // 指定重定向的URL
        c.Request.URL.Path = "/t2"
        r.HandleContext(c)
    })
    r.GET("/t2", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"hello": "t2"})
    })

    //学生，学校接口
    r.GET("/stu", RunCost("2006-01-02"), stuHandler)
    r.GET("/school", schoolHandler)

    //默认路由处理，防止404
    r.NoRoute(func(c *gin.Context) {
        c.String(http.StatusNotFound, "该页面禁止访问")
    })

    r.Run(":7777")
}

记录响应体的中间件

我们有时候可能会想要记录下某些情况下返回给客户端的响应数据，这个时候就可以编写一个中间件来搞定。


type bodyLogWriter struct {
    gin.ResponseWriter               // 嵌入gin框架ResponseWriter
    body               *bytes.Buffer // 我们记录用的response
}

// Write 写入响应体数据
func (w bodyLogWriter) Write(b []byte) (int, error) {
    w.body.Write(b)                  // 我们记录一份
    return w.ResponseWriter.Write(b) // 真正写入响应
}

// ginBodyLogMiddleware 一个记录返回给客户端响应体的中间件
// https://stackoverflow.com/questions/38501325/how-to-log-response-body-in-gin
func ginBodyLogMiddleware(c *gin.Context) {
    blw := &bodyLogWriter{body: bytes.NewBuffer([]byte{}), ResponseWriter: c.Writer}
    c.Writer = blw // 使用我们自定义的类型替换默认的

    c.Next() // 执行业务逻辑

    fmt.Println("Response body: " + blw.body.String()) // 事后按需记录返回的响应
}

跨域中间件cors

推荐使用社区的https://github.com/gin-contrib/cors 库，一行代码解决前后端分离架构下的跨域问题。

注意： 该中间件需要注册在业务处理函数前面。

这个库支持各种常用的配置项，具体使用方法如下。

package main

import (
  "time"

  "github.com/gin-contrib/cors"
  "github.com/gin-gonic/gin"
)

func main() {
  router := gin.Default()
  // CORS for https://foo.com and https://github.com origins, allowing:
  // - PUT and PATCH methods
  // - Origin header
  // - Credentials share
  // - Preflight requests cached for 12 hours
  router.Use(cors.New(cors.Config{
    AllowOrigins:     []string{"https://foo.com"},  // 允许跨域发来请求的网站
    AllowMethods:     []string{"GET", "POST", "PUT", "DELETE",  "OPTIONS"},  // 允许的请求方法
    AllowHeaders:     []string{"Origin", "Authorization", "Content-Type"},
    ExposeHeaders:    []string{"Content-Length"},
    AllowCredentials: true,
    AllowOriginFunc: func(origin string) bool {  // 自定义过滤源站的方法
      return origin == "https://github.com"
    },
    MaxAge: 12 * time.Hour,
  }))
  router.Run()
}

当然你可以简单的像下面的示例代码那样使用默认配置，允许所有的跨域请求。

不导入三方库，直接允许cors

func main() {
  router := gin.Default()
  // same as
  // config := cors.DefaultConfig()
  // config.AllowAllOrigins = true
  // router.Use(cors.New(config))
  router.Use(cors.Default())
  router.Run()
}

注册中间件

在gin框架中，我们可以为每个路由添加任意数量的中间件。

为全局路由注册

func main() {
    // 新建一个没有任何默认中间件的路由
    r := gin.New()
    // 注册一个全局中间件，多次调用Use，多次添加中间件
    r.Use(RunCost())
    r.GET("/test", func(c *gin.Context) {
        name := c.MustGet("name").(string) // 从gin.Context上下文取值
        log.Println(name)
        c.JSON(http.StatusOK, gin.H{
            "message": "Hello world!",
        })
    })
    r.Run()
}

为某个路由单独注册middleware

写在路由函数前，如RunCost()，并且可以写多个middleware，默认最多255个中间件。

// 给/test2路由单独注册中间件（可注册多个）
    r.GET("/test2", RunCost(), func(c *gin.Context) {
        name := c.MustGet("name").(string) // 从上下文取值
        log.Println(name)
        c.JSON(http.StatusOK, gin.H{
            "message": "Hello world!",
        })
    })

为路由组注册中间件

为路由组注册中间件有以下两种写法。

写法1：

shopGroup := r.Group("/shop", StatCost())
{
    shopGroup.GET("/index", func(c *gin.Context) {...})
    ...
}

写法2：

shopGroup := r.Group("/shop")
shopGroup.Use(RunCost())
{
    shopGroup.GET("/index", func(c *gin.Context) {...})
    ...
}

New()、Default()

func main() {
    //r := gin.Default()
    r := gin.New() //纯净得引擎

Default() 提供如Recover()功能的gin对象
New() 没有任何中间件功能

c.Next()、c.Abort()

//中间件结束后，继续执行stuHandler
c.Next()

//禁止向后执行，后面的stuHandler 不执行了
//c.Abort()

路由函数，可以按顺序注册多个middleware，以及对应func
通过next向后执行
或者Abort终止后续函数

也可以这么使用，利用Abort、return终止函数。

    //禁止向后执行，后面的stuHandler 不执行了
        //c.Abort()

        if c.Request.URL.Path == "/admin" {
            c.Abort()
            return
        }

中间件注意事项

gin默认中间件

gin.Default()默认使用了Logger和Recovery中间件，其中：

Logger中间件将日志写入gin.DefaultWriter，即使配置了GIN_MODE=release。
Recovery中间件会recover任何panic。如果有panic的话，会写入500响应码。

如果不想使用上面两个默认的中间件，可以使用gin.New()新建一个没有任何默认中间件的路由。

gin中间件中使用goroutine

当在中间件或handler中启动新的goroutine时，不能使用原始的上下文（c *gin.Context），必须使用其只读副本（c.Copy()）。

运行多个服务

先同步下go.mod

➜  goStudy go mod tidy
go: downloading github.com/stretchr/testify v1.8.1
go: downloading github.com/google/go-cmp v0.5.5
go: downloading github.com/go-playground/assert/v2 v2.2.0
go: downloading gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c
go: downloading github.com/kr/pretty v0.3.0
go: downloading golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
go: downloading gopkg.in/yaml.v3 v3.0.1
go: downloading github.com/pmezard/go-difflib v1.0.0
go: downloading github.com/rogpeppe/go-internal v1.8.0
go: finding module for package github.com/kr/text
go: finding module for package golang.org/x/sync/errgroup
go: downloading github.com/kr/text v0.2.0
go: found golang.org/x/sync/errgroup in golang.org/x/sync v0.1.0
go: found github.com/kr/text in github.com/kr/text v0.2.0
➜  goStudy

goroutine运行多个端口服务，我们可以在多个端口启动服务，例如

package main

import (
    "log"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "golang.org/x/sync/errgroup"
)

var (
    g errgroup.Group
)

func router01() http.Handler {
    e := gin.New()
    e.Use(gin.Recovery())
    e.GET("/", func(c *gin.Context) {
        c.JSON(
            http.StatusOK,
            gin.H{
                "code":  http.StatusOK,
                "error": "Welcome server 01",
            },
        )
    })

    return e
}

func router02() http.Handler {
    e := gin.New()
    e.Use(gin.Recovery())
    e.GET("/", func(c *gin.Context) {
        c.JSON(
            http.StatusOK,
            gin.H{
                "code":  http.StatusOK,
                "error": "Welcome server 02",
            },
        )
    })

    return e
}

func main() {
    server01 := &http.Server{
        Addr:         ":8080",
        Handler:      router01(),
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
    }

    server02 := &http.Server{
        Addr:         ":8081",
        Handler:      router02(),
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
    }
    // 借助errgroup.Group或者自行开启两个goroutine分别启动两个服务
    g.Go(func() error {
        return server01.ListenAndServe()
    })

    g.Go(func() error {
        return server02.ListenAndServe()
    })

    if err := g.Wait(); err != nil {
        log.Fatal(err)
    }
}

登录页面开发

简单校验后端

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

//参数校验，校验form 或json

// 对应前端登录数据，以及数据的key名
type Login struct {
    Username string `form:"username" json:"username" binding:"required"`
    Pwd      string `form:"pwd" json:"pwd" binding:"required"`
}

// 登录函数，传入gin.Context，由于要修改结构体，传入指针
func login(c *gin.Context) {
    //1.获取用户输入
    var reqData Login
    if err := c.ShouldBind(&reqData); err != nil {
        fmt.Println("解析请求错误：", err)
        c.JSON(http.StatusOK, gin.H{
            "code": "1",
            "msg":  "请求参数错误",
        })
        return
    }
    fmt.Printf("reqData:%#v\n", reqData)
    //账号密码校验
    if reqData.Username == "yuchao" && reqData.Pwd == "123" {
        fmt.Println("登录成功")
        c.JSON(http.StatusOK, gin.H{
            "code": "0",
            "msg":  fmt.Sprintf("hello %s", reqData.Username),
            "data": []string{reqData.Username, reqData.Pwd},
        })
        return
    } else {
        c.JSON(http.StatusOK, gin.H{
            "code": "1",
            "msg":  "账号、密码错误。",
        })
    }

}

func main() {
    router := gin.Default()
    //用户访问登录页面，get请求
    router.LoadHTMLFiles("./login.html")
    router.GET("/login", func(c *gin.Context) {
        c.HTML(http.StatusOK, "login.html", nil)
    })

    //用户提交账号密码
    router.POST("/login", login)
    //启动服务器
    router.Run(":9898")

}

前端form

<!DOCTYPE html>
<html lang="zh-CN">

<head>
    <title>login</title>
</head>

<body>
<form action="/login" method="post" enctype="multipart/form-data">
    用户名:<input type="text" name="username"><br>
    密&nbsp&nbsp&nbsp码:<input type="password" name="pwd"><br>
    <input type="submit" value="登录">
</form>
</body>

</html>

接入mysql

sql

CREATE TABLE `user` (
    `id` BIGINT NOT NULL AUTO_INCREMENT,
    `username` VARCHAR(32) UNIQUE,
    `password` VARCHAR(32) NOT NULL,
    PRIMARY KEY(`id`)
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;


MariaDB [login_db]> insert into user(username,password) values("yuchao","123");
Query OK, 1 row affected (0.00 sec)

后端

package main

import (
    "database/sql"
    "errors"
    "fmt"
    "log"
    "net/http"

    "github.com/gin-gonic/gin"
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
)

//引入mysql

var db *sqlx.DB

func main() {
    //直接先初始化mysql，连不上结束程序
    if err := initDB(); err != nil {
        log.Printf("Connect mysql failed，err：%#v\n", err)
        panic(err)
    }

    router := gin.Default()

    //用户访问登录页面，get请求
    router.LoadHTMLFiles("./login.html")
    router.GET("/login", func(c *gin.Context) {
        c.HTML(http.StatusOK, "login.html", nil)
    })

    //用户提交账号密码
    router.POST("/login", login)

    //启动服务器
    router.Run(":9898")

}

// 连接db，设置编码，以及时间解析
func initDB() (err error) {
    dsn := "root:yuchao666@tcp(yuchaoit.cn:3306)/login_db?charset=utf8mb4&parseTime=True"
    //连不上强制结束
    //务必注意，这里非局部声明
    db, err = sqlx.Connect("mysql", dsn)
    if err != nil {
        log.Printf("connect mysql failed, err:%#v\n", err)
        panic(err)
    }
    return
}

//参数校验，校验form 或json

// 对应前端登录数据，以及数据的key名
type Login struct {
    Username string `form:"username" json:"username" binding:"required"`
    Pwd      string `form:"pwd" json:"pwd" binding:"required"`
}

// 登录函数，传入gin.Context，由于要修改结构体，传入指针
func login(c *gin.Context) {
    //1.获取用户输入
    var reqData Login
    if err := c.ShouldBind(&reqData); err != nil {
        fmt.Println("解析请求错误：", err)
        c.JSON(http.StatusOK, gin.H{
            "code": "1",
            "msg":  "请求参数错误",
        })
        return
    }
    fmt.Printf("reqData:%#v\n", reqData)
    //账号密码校验
    //加入mysql数据库校验，封装校验函数
    //if reqData.Username == "yuchao" && reqData.Pwd == "123" {
    if u, err := QueryUser(reqData.Username, reqData.Pwd); err == nil {
        fmt.Println("登录成功", u)
        u.Desc = "有值了，我就显示了"
        c.JSON(http.StatusOK, gin.H{
            "code": "0",
            "msg":  fmt.Sprintf("welcome %s", u.Username),
            "data": u, //自动序列化struct > json
        })
        return
    } else {
        c.JSON(http.StatusOK, gin.H{
            "code": "1",
            "msg":  "账号、密码错误。",
        })
    }

}

// 封装用户表
// 使用json tag，转换字段给前端
// db tag，表示mysql表，与struct字段得一样
// sqlx库中规定的tag ，key就是db
type User struct {
    //告诉json包，不渲染改id字段
    Id int `db:"id" json:"-"`
    //修改前端json，key名字为name
    Username string `db:"username" json:"name"`
    //你还可以额外自定义添加，返回的新字段
    //有值就展示，没值就不展示omitempty忽略空的意思
    Desc string `json:"desc,omitempty"`
}

func QueryUser(username, password string) (*User, error) {
    //sql查询
    sqlStr := "select id ,username from user where username=? and password=?"
    var u User
    //mysql读出来的数据，写入自定义User结构体，因此转入指针
    err := db.Get(&u, sqlStr, username, password)
    if err != nil {
        fmt.Println(errors.Is(err, sql.ErrNoRows)) // 没有查询到记录
        fmt.Printf("数据库查询失败 , err:%v\n", err)
        return nil, err
    }
    return &u, nil
}

前端

<!DOCTYPE html>
<html lang="zh-CN">

<head>
    <title>login</title>
</head>

<body>
<form action="/login" method="post" enctype="multipart/form-data">
    用户名:<input type="text" name="username"><br>
    密&nbsp&nbsp&nbsp码:<input type="password" name="pwd"><br>
    <input type="submit" value="登录">
</form>
</body>

</html>

json包进阶

https://www.liwenzhou.com/posts/Go/json-tricks/

18-Gin开发

Gin框架介绍

Gin框架安装与使用

安装

第一个Gin示例

RESTful API

Gin渲染

HTML渲染

自定义模板函数

静态文件处理

使用模板继承

补充文件路径处理

r.Any()

JSON渲染

XML渲染

YMAL渲染

protobuf渲染

获取参数

获取querystring参数

获取form参数

获取json参数

获取path参数

参数绑定⭐️⭐️

c.ShouldBind方法

文件上传

单个文件上传

run和build的区别

多个文件上传

重定向

HTTP重定向

路由重定向

处理gin.Context数据

Gin路由

普通路由

r.Any()

r.NoRoute()

404路由处理

路由组

路由原理

Gin中间件

定义中间件

记录接口耗时的中间件

记录响应体的中间件

跨域中间件cors

注册中间件

为全局路由注册

为某个路由单独注册middleware

为路由组注册中间件

New()、Default()

c.Next()、c.Abort()

中间件注意事项

gin默认中间件

gin中间件中使用goroutine

运行多个服务

登录页面开发

简单校验后端

接入mysql

json包进阶

results matching ""

No results matching ""