---

初识框架

框架是一系列工具的集合，能让开发变的便捷。

学习框架的目的就是为了提供项目的开发效率，使我们更加专注业务，而不是和业务无关的底层代码。

go流行的web框架

如果学习过其他语言，可能知道Java用的比较多的是Spring框架，PHP用的比较多的是Laravel，python用的多的是Django，都在各自的语言中具有强大的统治力。

go从诞生之初就带有浓重的开源属性，其原生库已经很强大，即使不依赖框架，也能进行高性能开发，又因为其语言并没有一定的设计标准，所以较为灵活，也就诞生了众多的框架，各具有特色，满足不同的喜好。

Gin

地址：https://github.com/gin-gonic/gin

号称最快的go语言web框架，目前是go官方的推荐框架（https://go.dev/doc/tutorial/）。

iris

地址：https://github.com/kataras/iris

性能比gin高一些，支持MVC，但这款框架评价不太好，使用上问题较多，近些年很少去选择使用

Beego

地址：https://github.com/beego/beego

国人开发，最早的go web框架之一，工具集比较完善，性能较差，据传言作者是php转行，所以框架带有浓厚的php特色，早期国内使用的多，目前少有人选择。

fiber

地址：https://github.com/gofiber/fiber

2020年发布的框架，发展迅速，建立在fasthttp之上，性能目前最高，受Express启发，比较简洁，上手较快，和gin类似。

当然还有其他一些框架，但从star数上，以及流行程度上看，gin一骑绝尘，gin的好处在于其简洁，扩展性，稳定性以及性能都比较出色。

go的框架其实是可以理解为库，并不是用了某一个框架就不能用别的框架，可以选择性的使用各个库中的优秀组件，进行组合。

Gin介绍

特性：

• 快速

  基于 Radix 树的路由，小内存占用。没有反射。可预测的 API 性能。

• 支持中间件

  传入的 HTTP 请求可以由一系列中间件和最终操作来处理。 例如：Logger，Authorization，GZIP，最终操作 DB。

• Crash 处理

  Gin 可以 catch 一个发生在 HTTP 请求中的 panic 并 recover 它。这样，你的服务器将始终可用。例如，你可以向 Sentry 报告这个 panic！

• JSON 验证

  Gin 可以解析并验证请求的 JSON，例如检查所需值的存在。

• 路由组

  更好地组织路由。是否需要授权，不同的 API 版本…… 此外，这些组可以无限制地嵌套而不会降低性能。

• 错误管理

  Gin 提供了一种方便的方法来收集 HTTP 请求期间发生的所有错误。最终，中间件可以将它们写入日志文件，数据库并通过网络发送。

• 内置渲染

  Gin 为 JSON，XML 和 HTML 渲染提供了易于使用的 API。

• 可扩展性

  新建一个中间件非常简单。

Gin快速入门

go版本需求：go1.13及以上

环境：windows 11

# 创建工作区
F:\Code\Golang\TuLing\workPath>mkdir ginlearn
F:\Code\Golang\TuLing\workPath>cd ginlearn
# 初始化工作区
F:\Code\Golang\TuLing\workPath\ginlearn>go work init# 创建模块
F:\Code\Golang\TuLing\workPath\ginlearn>mkdir helloworld
F:\Code\Golang\TuLing\workPath\ginlearn>cd helloworld
# 初始化模块
F:\Code\Golang\TuLing\workPath\ginlearn\helloworld>go mod init test.com/helloworld
go: creating new go.mod: module test.com/helloworld
F:\Code\Golang\TuLing\workPath\ginlearn\helloworld>cd ..# 将模块加入工作区
F:\Code\Golang\TuLing\workPath\ginlearn>go work use ./helloworld

使用goland打开

下载gin

PS F:\Code\Golang\TuLing\workPath\ginlearn> cd .\helloworld\
PS F:\Code\Golang\TuLing\workPath\ginlearn\helloworld> go get -u github.com/gin-gonic/gin

示例程序，创建main.go

package mainimport "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 上启动服务
}

运行后，apifox进行测试

符合预期，这样简单的代码就实现了一个http的服务

路由

路由是URI到函数的映射。

一个URI含: http://localhost:8080/user/find?id=11

• 协议，比如http，https等
• ip端口或者域名，比如127.0.0.1:8080或者www.test.com
• path，比如 /path
• query，比如 ?query

同时访问的时候，还需要指明HTTP METHOD，比如

• GET

  GET方法请求一个指定资源的表示形式. 使用GET的请求应该只被用于获取数据.

• POST

  POST方法用于将实体提交到指定的资源，通常会导致在服务器上的状态变化

• HEAD

  HEAD方法请求一个与GET请求的响应相同的响应，但没有响应体.

• PUT

  PUT方法用请求有效载荷替换目标资源的所有当前表示

• DELETE

  DELETE方法删除指定的资源

• CONNECT

  CONNECT方法建立一个到由目标资源标识的服务器的隧道。

• OPTIONS

  OPTIONS方法用于描述目标资源的通信选项。

• TRACE

  TRACE方法沿着到目标资源的路径执行一个消息环回测试。

• PATCH

  PATCH方法用于对资源应用部分修改。

使用的时候，应该尽量遵循其语义

RESTful API规范

RESTful API 的规范建议我们使用特定的HTTP方法来对服务器上的资源进行操作。

比如：

1. GET，表示读取服务器上的资源
2. POST，表示在服务器上创建资源
3. PUT,表示更新或者替换服务器上的资源
4. DELETE，表示删除服务器上的资源
5. PATCH，表示更新/修改资源的一部分

请求方法

r.GET("/get", func(ctx *gin.Context) {ctx.JSON(200, "get")
})
r.POST("/post", func(ctx *gin.Context) {ctx.JSON(200, "post")
})
r.DELETE("/delete", func(ctx *gin.Context) {ctx.JSON(200, "delete")
})
r.PUT("/put", func(ctx *gin.Context) {ctx.JSON(200, "put")
})

如果想要支持所有：

r.Any("/any", func(ctx *gin.Context) {ctx.JSON(200, "any")
})

如果想要支持其中的几种：

r.GET("/hello", func(ctx *gin.Context) {//数组 map list 结构体ctx.JSON(200, gin.H{"name": "hello world",})
})
r.POST("/hello", func(ctx *gin.Context) {//数组 map list 结构体ctx.JSON(200, gin.H{"name": "hello world",})
})

URI

URI书写的时候，我们不需要关心scheme和authority这两部分，我们主要通过path和query两部分的书写来进行资源的定位。

静态url

比如/hello，/user/find

r.POST("/user/find", func(ctx *gin.Context) {
})

路径参数

比如/user/find/:id

r.POST("/user/find/:id", func(ctx *gin.Context) {param := ctx.Param("id")ctx.JSON(200, param)
})

模糊匹配

比如/user/*path

r.POST("/user/*path", func(ctx *gin.Context) {param := ctx.Param("path")ctx.JSON(200, param)
})

处理函数

定义：

type HandlerFunc func(*Context)

通过上下文的参数，获取http的请求参数，响应http请求等。

分组路由

在进行开发的时候，我们往往要进行模块的划分，比如用户模块，以user开发，商品模块，以goods开头。

或者进行多版本开发，不同版本之间路径是一致的，这种时候，就可以用到分组路由了。

比如

ug := r.Group("/user")
{ug.GET("find", func(ctx *gin.Context) {ctx.JSON(200, "user find")})ug.POST("save", func(ctx *gin.Context) {ctx.JSON(200, "user save")})
}
gg := r.Group("/goods")
{gg.GET("find", func(ctx *gin.Context) {ctx.JSON(200, "goods find")})gg.POST("save", func(ctx *gin.Context) {ctx.JSON(200, "goods save")})
}

请求路径则为

[GIN-debug] GET    /user/find                --> main.main.func2 (3 handlers)
[GIN-debug] POST   /user/save                --> main.main.func3 (3 handlers)
[GIN-debug] GET    /goods/find               --> main.main.func4 (3 handlers)
[GIN-debug] POST   /goods/save               --> main.main.func5 (3 handlers)

请求参数

GET请求参数

使用Get请求传参时，类似于这样

http://localhost:8080/user/save?id=11&name=zhangsan

如何获取呢？

普通参数

request url: http://localhost:8080/user/save?id=11&name=zhangsan

• Query：匹配字段

  r.GET("/user/save", func(ctx *gin.Context) {id := ctx.Query("id")name := ctx.Query("name")ctx.JSON(200, gin.H{"id":   id,"name": name,})
  })
  

  如果参数不存在，就给一个默认值：

• DefaultQuery：query为空时回返回个默认值

  r.GET("/user/save", func(ctx *gin.Context) {id := ctx.Query("id")name := ctx.Query("name")address := ctx.DefaultQuery("address", "北京")ctx.JSON(200, gin.H{"id":      id,"name":    name,"address": address,})
  })
  

• GetQuery：多了个query成功与否的返回值

  r.GET("/user/save", func(ctx *gin.Context) {id, ok := ctx.GetQuery("id")address, aok := ctx.GetQuery("address")ctx.JSON(200, gin.H{"id":      id,"idok":    ok,"address": address,"aok":     aok,})
  })
  

  id是数值类型，上述获取的都是string类型，根据类型获取：通过form进行字段匹配

• BindQuery：与结构体字段进行匹配

  type User struct {Id   int64  `form:"id"`Name string `form:"name"`
  }
  r.GET("/user/save", func(ctx *gin.Context) {var user Usererr := ctx.BindQuery(&user)if err != nil {log.Println(err)}ctx.JSON(200, user)
  })
  

• ShouldBindQuery：有binding字段的要求必填，否则报错

  r.GET("/user/save", func(ctx *gin.Context) {var user Usererr := ctx.ShouldBindQuery(&user)if err != nil {log.Println(err)}ctx.JSON(200, user)
  })
  

  区别：

  当bind是必须的时候，ShouldBindQuery会报错，开发者自行处理，状态码不变。

  type User struct {Id      int64  `form:"id"`Name    string `form:"name"`Address string `form:"address" binding:"required"`
  }
  

  BindQuery则报错的同时，会将状态码改为400。所以一般建议是使用Should开头的bind。

数组参数

请求url：http://localhost:8080/user/save?address=Beijing&address=shanghai

• QueryArray：重复查询字段组装成数组

  r.GET("/user/save", func(ctx *gin.Context) {address := ctx.QueryArray("address")ctx.JSON(200, address)
  })
  

• GetQueryArray：多成功与否返回值

  r.GET("/user/save", func(ctx *gin.Context) {address, ok := ctx.GetQueryArray("address")fmt.Println(ok)ctx.JSON(200, address)
  })
  

• ShouldBindQuery

  r.GET("/user/save", func(ctx *gin.Context) {var user Usererr := ctx.ShouldBindQuery(&user)fmt.Println(err)ctx.JSON(200, user)
  })
  

  但是这样的话我们的user的address要求就是个数组

  type User struct {Id      int64    `form:"id"`Name    string   `form:"name"`Address []string `form:"address" binding:"required"`
  }
  

  成功返回

  {"Id": 0,"Name": "","Address": ["Beijing","shanghai"]
  }
  

map参数

请求url：http://localhost:8080/user/save?addressMap[home]=Beijing&addressMap[company]=shanghai

• QueryMap：组装成map

  r.GET("/user/save", func(ctx *gin.Context) {addressMap := ctx.QueryMap("addressMap")ctx.JSON(200, addressMap)
  })
  

• GetQueryMap：多成功与否返回值

  r.GET("/user/save", func(ctx *gin.Context) {addressMap, _ := ctx.GetQueryMap("addressMap")ctx.JSON(200, addressMap)
  })
  

  返回值

  {"company": "shanghai","home": "Beijing"
  }
  

POST请求参数

post请求一般是表单参数和json参数

表单参数

r.POST("/user/save", func(ctx *gin.Context) {id := ctx.PostForm("id")name := ctx.PostForm("name")address := ctx.PostFormArray("address")addressMap := ctx.PostFormMap("addressMap")ctx.JSON(200, gin.H{"id":         id,"name":       name,"address":    address,"addressMap": addressMap,})
})

• PostForm：从表单中对应的字段
• PostFormArray：从表单找对应的数组
• PostFormMap：从表单找对应的Map

r.POST("/user/save", func(ctx *gin.Context) {var user Usererr := ctx.ShouldBind(&user)addressMap, _ := ctx.GetPostFormMap("addressMap")user.AddressMap = addressMapfmt.Println(err)ctx.JSON(200, user)
})

• GetPostFormMap：从表单找对应的Map

JSON参数

json参数如下

{"id":1111,"name":"zhangsan","address": ["beijing","shanghai"],"addressMap":{"home":"beijing"}
}

r.POST("/user/save", func(ctx *gin.Context) {var user Usererr := ctx.ShouldBindJSON(&user)fmt.Println(err)ctx.JSON(200, user)
})

对应字段进行匹配

其他类型参数注入xml，yaml等和json道理一样

路径参数

请求url：http://localhost:8080/user/save/111

r.POST("/user/save/:id", func(ctx *gin.Context) {ctx.JSON(200, ctx.Param("id"))
})

• :id 表示 占位符，可以匹配 任意路径中的值。

• ctx.Param("id") 用于 获取路径参数 id 的值。

文件参数

r.POST("/user/save", func(ctx *gin.Context) {form, err := ctx.MultipartForm()if err != nil {log.Println(err)}files := form.Filefor _, fileArray := range files {for _, v := range fileArray {ctx.SaveUploadedFile(v, "./"+v.Filename)}}ctx.JSON(200, form.Value)
})

在form表单中请求file类型

这样就能在本地看到了

响应

字符串方式

r.GET("/user/save", func(ctx *gin.Context) {ctx.String(http.StatusOK, "this is a %s", "ms string response")
})

JSON方式

r.GET("/user/save", func(ctx *gin.Context) {ctx.JSON(http.StatusOK, gin.H{"success": true,})
})

XML方式

r.GET("/user/save", func(ctx *gin.Context) {u := XmlUser{Id:   11,Name: "zhangsan",}ctx.XML(http.StatusOK, u)
})

文件方式

r.GET("/user/save", func(ctx *gin.Context) {//ctx.File("./1.png")ctx.FileAttachment("./1.png", "2.png")
})

设置http响应头

r.GET("/user/save", func(ctx *gin.Context) {ctx.Header("test", "headertest")
})

重定向

r.GET("/user/save", func(ctx *gin.Context) {ctx.Redirect(http.StatusMovedPermanently, "http://www.baidu.com")
})

YAML方式

r.GET("/user/save", func(ctx *gin.Context) {ctx.YAML(200, gin.H{"name": "ms", "age": 19})
})