Go语言上手（四）-Gin上手 | 青训营笔记

这是我参与「第五届青训营 」伴学笔记创作活动的第 4 天

今天没有课程计划，但是我学习了gin的框架

今日收获
学习了gin的基本操作

先看官方文档

快速入门 | Gin Web Framework (gin-gonic.com)

安装gin

PS H:\Gin> go get -u github.com/gin-gonic/gin

go.mod

module Gin
​
go 1.19
​
require (
    github.com/gin-contrib/sse v0.1.0 // indirect
    github.com/gin-gonic/gin v1.8.2 // indirect
    github.com/go-playground/locales v0.14.1 // indirect
    github.com/go-playground/universal-translator v0.18.0 // indirect
    github.com/go-playground/validator/v10 v10.11.1 // indirect
    github.com/goccy/go-json v0.10.0 // indirect
    github.com/json-iterator/go v1.1.12 // indirect
    github.com/leodido/go-urn v1.2.1 // indirect
    github.com/mattn/go-isatty v0.0.17 // indirect
    github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
    github.com/modern-go/reflect2 v1.0.2 // indirect
    github.com/pelletier/go-toml/v2 v2.0.6 // indirect
    github.com/ugorji/go/codec v1.2.8 // indirect
    golang.org/x/crypto v0.5.0 // indirect
    golang.org/x/net v0.5.0 // indirect
    golang.org/x/sys v0.4.0 // indirect
    golang.org/x/text v0.6.0 // indirect
    google.golang.org/protobuf v1.28.1 // indirect
    gopkg.in/yaml.v2 v2.4.0 // indirect
)
​

可以看到项目下生成依赖

基础配置

package main
​
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
​
func main() {
    // 创建路由
    r := gin.Default()
    // 绑定路由
    r.GET("/", func(context *gin.Context) {
        context.String(http.StatusOK, "hello world !")
    })
​
    // 监听 默认为8080
    r.Run(":8000")
}
​

运行之后打开浏览器

输入地址

成功

json

map构造json

//json
data := map[int]interface{}{
   1: "1",
   2: "2",
   3: 3,
}
r.GET("/jsonByMap", func(context *gin.Context) {
   context.JSON(http.StatusOK, data)
})

{"1":"1","2":"2","3":3}

默认构造

r.GET("/jsonByDefault", func(context *gin.Context) {
        context.JSON(http.StatusOK, gin.H{
            "1": 1,
            "2": 3,
        })
    })

查看源码

utils.go

// H is a shortcut for map[string]interface{}
type H map[string]any

H 是一个map 键-string 值- any 对 非标准的go sdk

使用结构体

r.GET("/jsonByStruct", func(context *gin.Context) {
   // 定义结构体
   type data struct {
      Name    string
      Message string
      Age     int
   }
   d := data{
      Name:    "bowen",
      Message: "hello",
      Age:     0,
   }
   context.JSON(http.StatusOK, d)
})

{"Name":"bowen","Message":"hello","Age":0}

注意 结构体的大写才能初始化 不能被解析 不能被导出

如果要使用别名 后加

`json:"name"`

get

普通请求

请求获取参数

query

r.GET("/get", func(context *gin.Context) {
   name := context.Query("query")
   context.JSON(http.StatusOK, name)
})

其他的api

DefaultQuery

// // DefaultQuery returns the keyed url query value if it exists,
//// otherwise it returns the specified defaultValue string.
//// See: Query() and GetQuery() for further information.
////     GET /?name=Manu&lastname=
////     c.DefaultQuery("name", "unknown") == "Manu"
////     c.DefaultQuery("id", "none") == "none"
////     c.DefaultQuery("lastname", "none") == ""
func (c *Context) DefaultQuery(key, defaultValue string) string {
    xxx
}

也就是默认的参数，取不到第一个参数就返回使用默认的第二个参数

GetQuery

// GetQuery is like Query(), it returns the keyed url query value
// if it exists `(value, true)` (even when the value is an empty string),
// otherwise it returns `("", false)`.
// It is shortcut for `c.Request.URL.Query().Get(key)`
//     GET /?name=Manu&lastname=
//     ("Manu", true) == c.GetQuery("name")
//     ("", false) == c.GetQuery("id")
//     ("", true) == c.GetQuery("lastname")
func (c *Context) GetQuery(key string) (string, bool) {
xxx
}

也就是会返回两参数 第一个为取得值，第二个为是否取到参数（bool）

获取url参数

/:name/:age

加上:可以获取name和age的值

name := context.Param("name")

Post

PostForm

name := context.PostForm("name")

取不到返回空字符串

DefaultPostForm

与上面的get请求类似

取到返回值，否则为默认值

GetPostForm

和上面的get类似

绑定结构体

使用ShouldBind()方法

注意要传递地址 使用&

源码

// ShouldBind checks the Method and Content-Type to select a binding engine automatically,
// Depending on the "Content-Type" header different bindings are used, for example:
//     "application/json" --> JSON binding
//     "application/xml"  --> XML binding
// It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
// It decodes the json payload into the struct specified as a pointer.
// Like c.Bind() but this method does not set the response status code to 400 or abort if input is not valid.
func (c *Context) ShouldBind(obj any) error {
   b := binding.Default(c.Request.Method, c.ContentType())
   return c.ShouldBindWith(obj, b)
}

同时使用反射，动态获取

这里定义结构体必须大写，不然无法取到结构体的字段

这里定义结构体要指定

Gin中提供了模型绑定，将表单数据和模型进行绑定，方便参数校验和使用。

使用如下

// 表单数据
type LoginForm struct {
    UserName  string    `form:"username"`    
    Password  string    `form:"password"`
    Email     string    `form:"email"`  
}

如果匹配不上赋值为空

可以混合使用

type student struct {
    Username string `form:"username" json:"username"`
    Password string `form:"password" json:"password"`
}

互不影响

文件上传

单个文件上传

FormFile方法会读取参数“upload”后面的文件名，返回值是一个File指针，和一个FileHeader指针，和一个err错误。

router.POST("/upload", func(c *gin.Context) {
        // 单文件
        file, _ := c.FormFile("file")
        log.Println(file.Filename)
​
        dst := "./" + file.Filename
        // 上传文件至指定的完整文件路径
        c.SaveUploadedFile(file, dst)
​
        c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
    })

请求重定向

请求重定向

内部重定向

context.Redirect(http.StatusMovedPermanently, "http://localhost/8000/index")

路由重定向

r.GET("redirect", func(context *gin.Context) {
        context.Request.URL.Path = "/index"
        r.HandleContext(context)
    })

路由重定向

路由分组

也就是路由的选择，更加优雅和有效，能够跟轻松的展示自己的操作逻辑

// 设置路由
router := gin.Default()
// 第一个参数是：路径； 第二个参数是：具体操作 func(c *gin.Context)
router.GET("/Get", getting)
router.POST("/Post", posting)
router.PUT("/Put", putting)
router.DELETE("/Delete", deleting)
router.Any('/any',any) //任何类型
route.NoRoute() //不存在的请求
// 默认启动的是 8080端口
router.Run()

路由组

// 两个路由组，都可以访问，大括号是为了保证规范
v1 := r.Group("/v1")
{
    // 通过 localhost:8080/v1/hello访问，以此类推
    v1.GET("/hello", sayHello)
    v1.GET("/world", sayWorld)
}
v2 := r.Group("/v2")
{
    v2.GET("/hello", sayHello)
    v2.GET("/world", sayWorld)
}
r.Run(":8080")

大量路由实现

当我们的路由变得非常多的时候，那么建议遵循以下步骤：

1. 建立routers包，将不同模块拆分到多个go文件
2. 每个文件提供一个方法，该方法注册实现所有的路由
3. 之后main方法在调用文件的方法实现注册

// 这里是routers包下某一个router对外开放的方法 传入变量的指针
func LoadRouter(e *gin.Engine) {
    e.Group("v1")
    {
        v1.GET("/post", postHandler)
        v1.GET("/get", getHandler)
    }
    ...
}

中间件

相当于java的拦截器

// 中间件
func indexHandler(context *gin.Context) {
    fmt.Println("中间件")
    fmt.Println("index开始执行")
    context.Next()
    // 阻止调用 context.Abort()
    fmt.Println("index执行结束")
}
func lastHandler(context *gin.Context) {
    fmt.Println("执行last")
}

r.GET("/indexHandler", indexHandler, lastHandler)

中间件 index开始执行 执行last index执行结束

gin.defalut()默认使用logger()和recover的中间件

使用协程使用copy并发，不然会产生不可预料的后果

设计

Gin框架没有对项目结构做出限制，我们可以根据自己项目需要自行设计。

我的目前的想法是
service 层
model 层
controller 层
route 层定义路由和相关的规则
pre 层定义中间件和使用
config 层定义基本的配置