Go 语言中的 gin 框架

Gin 是一个用 Go (Golang) 编写的 HTTP web 框架。

官方文档

假如还没有装置Go语言开发环境，参阅一下我的这篇文章：

第 N 次Hello World ! Ready ？Go !

码云地址

完好demo代码放在码云上了，需自取

Gitee

新建项目初始化，以及装置

新建文件夹后，初始化 go.mod 文件

//初始化
go mod init gin

下载装置Gin

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

tips：踩坑指南

go get 指令下载gin包时出现报错

go在1.13版别后，默许敞开了：

GOSUMDB=sum.golang.org

而这个网址sum.golang.org 在国内是无法拜访，故需求关闭

解决方案：

go env -w GOSUMDB=off

更换国内源

go env -w GO111MODULE=on

go env -w GOPROXY=mirrors.aliyun.com/goproxy/,di…

首要，运用Gin输出一个 Ready?Go!

新建文件

在文件夹中新建 main.go 文件

导入Gin

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

假如运用比如 http.StatusOK 之类的常量，则需求引进 net/http 包

import "net/http"

官网的demo

package main
import "github.com/gin-gonic/gin"
func main() {
r := gin.Default()
r.GET("/ping", func(c *gin.Context) {
c.JSON(200, gin.H{
"message": "pong",
})
})
r.Run() // 监听并在 0.0.0.0:8080 上发动服务
}

自己的代码

简略分析一下，每一步做了什么

package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
        // 创建服务，Default回来一个默许的路由引擎
        ginServer := gin.Default()
        // GET 办法, 增加路由地址和回调函数
        // Gin进行了封装，把request和response都封装到了gin.Context的上下文环境中。
        ginServer.GET("/", func(context *gin.Context) {
        context.String(http.StatusOK, "Ready?Go!")
    })
    // 服务器端口 假如不传端口号，默许8080
    ginServer.Run(":8082")
}

运行项目，经过指令发动，或者直接在IDE开发工具中发动。

go run main.go

浏览器拜访地址：

http://localhost:8082/

成功输出：Ready?Go!

看一下上面的代码，回调函数中的 gin.Context

除了回来 Json 和 String 当然还能够回来 HTML页面。

加载静态资源和页面

呼应一个前端页面

// 呼应一个前端页面
ginServer.GET("/index", func(context *gin.Context) {
    context.HTML(http.StatusOK, "index.html", gin.H{"title": "gin web页面"})
})

运用 ico 文件

装置指令

go get "github.com/thinkerou/favicon"

// 运用 favicon.ico 文件
ginServer.Use(favicon.New("./favicon.ico"))

加载静态页面

// 加载静态页面
ginServer.LoadHTMLGlob("templates/*")

加载资源文件

// 加载资源文件
ginServer.Static("/static", "./static")

项目结构

点击概况，查看完好代码

package main
import (
   "github.com/gin-gonic/gin"
   "github.com/thinkerou/favicon"
   "net/http"
)
func main() {
   // 创建服务，Default回来一个默许的路由引擎
   ginServer := gin.Default()
   // 运用 favicon.ico 文件
   ginServer.Use(favicon.New("./favicon.ico"))
   // 加载静态页面
   ginServer.LoadHTMLGlob("templates/*")
   // 加载资源文件
   ginServer.Static("/static", "./static")
   // 呼应一个前端页面
   ginServer.GET("/index", func(context *gin.Context) {
      context.HTML(http.StatusOK, "index.html", gin.H{"title": "gin web页面"})
   })
   // 服务器端口
   ginServer.Run(":8082")
}    

Restful API

Gin 是一个标准的 Web 服务框架

遵循 Restful API 接口标准

// Gin RESTful API
ginServer.POST("/user", func(context *gin.Context) {
    context.JSON(200, gin.H{"message": "post user"})
})
ginServer.PUT("/user", func(context *gin.Context) {
    context.JSON(200, gin.H{"message": "put user"})
})
ginServer.DELETE("/user", func(context *gin.Context) {
    context.JSON(200, gin.H{"message": "delete user"})
})

参数处理

Query接纳参数

Query接纳参数，经过 gin.Context 的 Query 函数获取参数。

// 接纳前端传递过来的参数
ginServer.GET("/user/info", func(context *gin.Context) {
    userid := context.Query("userid")
    username := context.Query("username")
    context.JSON(http.StatusOK, gin.H{
        "userid": userid,
        "username": username,
    })
})

Param 函数获取恳求 Path 中的参数

path 参数，可经过 Param 函数获取恳求 Path 中的参数。

Path 途径中参数以:开头。

// userinfo/info/123/orzr3
ginServer.GET("/user/info/:userid/:username", func(context *gin.Context) {
    userid := context.Param("userid")
    username := context.Param("username")
    context.JSON(http.StatusOK, gin.H{
        "userid": userid,
        "username": username,
    })
})

传递 json 数据

// 传递 json 数据
ginServer.POST("/json", func(context *gin.Context) {
    // request.body
    data, _ := context.GetRawData()
    var m map[string]interface{}
    // 包装成json 数据
    _ = json.Unmarshal(data, &m)
    context.JSON(http.StatusOK, m)
})

运用 postman 测试

表单提交示例

web页面代码

<form action="/user/add" method="post">
    <p>username: <input type="text" name="username" /></p>
    <p>password: <input type="text" name="password" /></p>
    <button type="submit">提交</button>
</form>

go代码

// user/add 增加数据
// 支持函数式编程 java不能把函数作为参数传递，go能够
ginServer.POST("/user/add", func(context *gin.Context) {
    // 获取前端传递过来的参数
    username := context.PostForm("username")
    password := context.PostForm("password")
    if username == "" || password == "" {
        context.JSON(http.StatusOK, gin.H{
        "code": 400,
        "msg": "参数错误",
        })
        return
    }
// 回来给前端
    context.JSON(http.StatusOK, gin.H{
        "msg": "ok",
        "username": username,
        "password": password,
    })
})

点击提交后，触发action恳求： /user/add

{“msg”:”ok”,”password”:”222″,”username”:”11″}

其他

路由重定向

// 路由重定向
ginServer.GET("/redirect", func(context *gin.Context) {
    // 重定向 301 http.StatusMovedPermanently
    context.Redirect(http.StatusMovedPermanently, "https://www.bilibili.com")
})

404 NoRoute

// 404 NoRoute
ginServer.NoRoute(func(context *gin.Context) {
    // context.JSON(http.StatusNotFound, gin.H{
    // "code": 404,
    // "msg": "404 not found",
    // })
    context.HTML(http.StatusNotFound, "404.html", nil)
})

路由组

// 路由组 /system/add 路由组的写法
systemGroup := ginServer.Group("/system")
{
    systemGroup.GET("/add", func(context *gin.Context) {
        context.JSON(http.StatusOK, gin.H{
            "msg": "system add",
        })
    })
    systemGroup.DELETE("/delete", func(context *gin.Context) {
        context.JSON(http.StatusOK, gin.H{
            "msg": "system delete",
        })
    })
}

中间件

中间件对HTTP Request恳求进行阻拦处理

// 自定义Go中间件 阻拦器
func MyMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Do something before request
        // 经过自定义的中间件，设置的值，在后续处理只要调用了这个中间件，就能够获取到这个值
        c.Set("usersession", "orzr3-123456")
        c.Next() // 一定要调用该办法，不然后续的处理不会被执行
        // c.Abort() // 一旦调用了该办法，后续的处理都不会被执行
        // Do something after request
    }
}

接纳前端传递过来的参数，而且运用中间件

// 接纳前端传递过来的参数，而且运用中间件
ginServer.GET("/user/info/handler", MyMiddleware(), func(context *gin.Context) {
    // 获取中间件中设置的值
    userSession := context.MustGet("usersession").(string)
    // 打印
    log.Println("userSession:================>", userSession)
    userid := context.Query("userid")
    username := context.Query("username")
    context.JSON(http.StatusOK, gin.H{
        "userid": userid,
        "username": username,
        "userSession": userSession,
    })
})

最终的话

以上，假如对你有用的话，不妨点赞保藏重视一下，谢谢

微信公众号: OrzR3

不定期更新一些技术类，生活类，读书类的文章。