当前位置：移动技术网 > IT编程>脚本编程>Go语言 > Gin框架介绍及使用

Gin框架介绍及使用

2019年10月26日 | 移动技术网IT编程 | 我要评论

gin框架介绍及使用

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

gin框架介绍

go世界里最流行的web框架，github上有24k+star。基于开发的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的简称，中文翻译为“表征状态转移”或“表现层状态转化”。

请求方法	url	含义
get	/book	查询书籍信息
post	/create_book	创建书籍记录
post	/update_book	更新书籍信息
post	/delete_book	删除书籍信息

请求方法	url	含义
get	/book	查询书籍信息
post	/book	创建书籍记录
put	/book	更新书籍信息
delete	/book	删除书籍信息

gin渲染

html渲染

我们首先定义一个存放模板文件的templates文件夹，然后在其内部按照业务分别定义一个posts文件夹和一个users文件夹。 posts/文件的内容如下：

{{define "posts/"}}
<!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/文件的内容如下：

{{define "users/"}}
<!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/", "templates/users/")
    r.get("/posts/index", func(c *gin.context) {
        c.html(http.statusok, "posts/", gin.h{
            "title": "posts/index",
        })
    })

    r.get("users/index", func(c *gin.context) {
        c.html(http.statusok, "users/", 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框架中的路由使用的是这个库。

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

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

如何用golang运行第一个项目

安装一些必要的环境1.下载go sdk (本人装的是1.9) 2.下载golang3.下载git 因为有些依赖要用 go get 去github上获取 4.配... [阅读全文]
Go打包二进制文件的实现

背景众所周知，go语言可打包成目标平台二进制文件是其一大优势，如此go项目在服务器不需要配置go环境和依赖就可跑起来。操作需求：打包部署到centos7笔者打包... [阅读全文]
golang包快速生成base64验证码的方法

base64captcha快速生成base64编码图片验证码字符串支持多种样式,算术,数字,字母,混合模式,语音模式.base64是网络上最常见的用于传输8bi... [阅读全文]
使用Go语言创建WebSocket服务的实现示例

今天介绍如何用 go 语言创建 websocket 服务，文章的前两部分简要介绍了 websocket 协议以及用 go 标准库如何创建 websocket 服... [阅读全文]
Golang通过小程序获取微信openid的方法示例

为什么要获取小程序的 openid在开发微信小程序的过程中，小程序可以通过微信官方提供的登录能力方便地获取微信提供的用户身份标识，快速建立小程序内的用户体系。那... [阅读全文]
golang语言编码规范的实现

本规范旨在为日常go项目开发提供一个代码的规范指导，方便团队形成一个统一的代码风格，提高代码的可读性，规范性和统一性。本规范将从命名规范，注释规范，代码风格和 ... [阅读全文]
Windows下安装VScode 并使用及中文配置方法

首先明确一点，vscode是开发go应用的基础编辑器，是microsoft（微软的产品），可以运行在windows、linux、mac os x上使用，默认提供... [阅读全文]
GoLang之使用Context控制请求超时的实现

起因之前接触了一个需求：提供一个接口，这个接口有一个超时时间，如果超时了返回超时异常；这个接口中调用其他的接口，如果调用超时了，所有... [阅读全文]
Golang HTTP 服务平滑重启及升级的思路

golang http服务在上线时，需要重新编译可执行文件，关闭正在运行的进程，然后再启动新的运行进程。对于访问频率比较高的面向终端用户的产品，关闭、重启的过程... [阅读全文]
VSCode1.4 搭建Golang的开发调试环境(遇到很多问题)

浪费我一天时间！唉唉唉唉唉~下载包的位置： 386 指32位系统 amd64 指64位系统还没有发现有什么区别！1、 liteide2、subli... [阅读全文]

网友评论


验证码：