文章目录
Gin介绍
安装
快速开始
路径参数
构造参数
post传参
get+post混合形式
构造Map格式
分组路由
Gin介绍
Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确，已经发布了1.0版本。具有快速灵活，容错方便等特点。其实对于golang而言，web框架的依赖要远比Python，Java之类的要小。自身的net/http足够简单，性能也非常不错。框架更像是一些常用函数或者工具的集合。借助框架开发，不仅可以省去很多常用的封装带来的时间，也有助于团队的编码风格和形成规范。
安装
下载安装
$ go get -u github.com/gin-gonic/gin
1
项目中导入
import "github.com/gin-gonic/gin"
1
（可选）导入NET/HTTP。例如，如果使用诸如HTTP.StasuCK之类的常数，则需要这样做。
import "net/http"
1
快速开始
让我们先通过一个简单的例子，迅速的了解以下
以下demo代码摘自Gin的github实例
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()
}
1
2
3
4
5
6
7
8
9
10
11
通过$ go run quick.go 启动
然后浏览器输入http://0.0.0.0:8080/ping
浏览器会渲染输出为：{"message":"pong"}
当然我们还可以利用如下的方式，渲染浏览器页面输出字符串
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
router := gin.Default()
router.GET("/someGet", getting)
router.Run()
}
func getting(c *gin.Context){
c.String(http.StatusOK,"Hello gin")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
浏览器会渲染输出为：Hello gin
我们点开源码发现，不管是渲染输出json格式、还是简单的字符串都是调用了c.Render方法，以下只是列出了2种，还有其他的诸如HTML、IndentedJSON、SecureJSON、JSONP、AsciiJSON、XML、YAML、ProtoBuf等
func (c *Context) String(code int, format string, values ...interface{}) {
c.Render(code, render.String{Format: format, Data: values})
}
1
2
3
func (c *Context) JSON(code int, obj interface{}) {
c.Render(code, render.JSON{Data: obj})
}
1
2
3
路径参数
func main() {
router := gin.Default()
router.GET("/someGet/:name", getting)
router.Run()
}
func getting(c *gin.Context){
name:=c.Param("name")
c.String(http.StatusOK,"Hello%s",name)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
以上函数的路由将会匹配 /user/john格式，但是不回匹配 /user/ 或者 /user
所以我们浏览器输入http://0.0.0.0:8080/someGet/aaaa可以
http://0.0.0.0:8080/someGet/或者http://0.0.0.0:8080/someGet都报错误
以上是一个参数，我们还可以定义多级参数，例如下面的例子：
以上的路由函数可以匹配 /user/john/ 或者 /user/john/send
但是不会匹配 /user/john, 报异常
例如浏览器输入http://0.0.0.0:8080/someGet/aaaa/，页面输出Helloaaaa-/
例如浏览器输入http://0.0.0.0:8080/someGet/aaaa/gg,页面输出Helloaaaa-/gg
例如浏览器输入http://0.0.0.0:8080/someGet/aaaa/gg/cc，页面输出Helloaaaa-/gg/cc
但是浏览器输入http://0.0.0.0:8080/someGet/aaaa，报异常404 page not found
构造参数
我们除了可以获取路径参数，还可以获取构造的参数，我们看下面的例子
func main() {
router := gin.Default()
router.GET("/someGet", getting)
router.Run()
}
func getting(c *gin.Context){
firstname := c.DefaultQuery("firstname", "Guest")
lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
浏览器输入http://0.0.0.0:8080/someGet?firstname=wyf&lastname=123
渲染页面输出为Hello wyf 123
浏览器输入http://0.0.0.0:8080/someGet?lastname=123，渲染页面输出为Hello Guest 123
post传参
这里为利用了postman进行演示操作
func main() {
router := gin.Default()
router.POST("/someGet", getting)
router.Run()
}
func getting(c *gin.Context){
message := c.PostForm("message")
nick := c.DefaultPostForm("nick", "anonymous")
c.JSON(200, gin.H{
"status": "posted",
"message": message,
"nick": nick,
})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
效果图如下：
get+post混合形式
func main() {
router := gin.Default()
router.POST("/someGet", getting)
router.Run()
}
func getting(c *gin.Context){
id := c.Query("id")
page := c.DefaultQuery("page", "0")
name := c.PostForm("name")
message := c.PostForm("message")
c.String(http.StatusOK,"id: %s; page: %s; name: %s; message: %s", id, page, name, message)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
效果图如下：
构造Map格式
这样的格式以前我还没见过，感觉挺新鲜的，看下代码
func main() {
router := gin.Default()
router.POST("/someGet", getting)
router.Run()
}
func getting(c *gin.Context){
ids := c.QueryMap("ids")
names := c.PostFormMap("names")
fmt.Printf("ids: %v; names: %v", ids, names)
c.JSON(200,gin.H{
"ids":ids,
"names":names,
})
c.String(http.StatusOK,"ids: %v; names: %v", ids, names)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
fmt输出如下：
ids: map[b:hello a:1234]; names: map[first:thinkerou second:tianou]
1
效果图如下：
分组路由
我们还可以进行路由分组设置，看下面的例子
package main
import (
"fmt"
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
v1 := router.Group("/v1")
{
v1.GET("/read", readEndpoint)
}
v2 := router.Group("/v2")
{
v2.GET("/login", loginEndpoint)
}
router.Run(":8080")
}
func readEndpoint(c *gin.Context) {
fmt.Println("read")
}
func loginEndpoint(c *gin.Context) {
fmt.Println("login")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
浏览器输入http://127.0.0.1:8080/v1/read
后台log输出read
浏览器输入http://127.0.0.1:8080/v2/login
后台log输出login
文章目录Gin介绍安装快速开始路径参数构造参数post传参get+post混合形式构造Map格式分组路由Gin介绍Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确，已经发布了1.0版本。具有快速灵活，容错方便等特点。其实对于golang而言，web框架的依赖要远比Python，Java之类的要小。自身的net/http足够简单，性能也非常不错。框架更像是一些常用函数或者工具的集合。借助框架开发，不仅可以省去很多常用的封装带来的时间，也有助于团队的编码风格和形成规范。
安装下载安装
$ go get -u github.com/gin-gonic/gin1项目中导入
import "github.com/gin-gonic/gin"1（可选）导入NET/HTTP。例如，如果使用诸如HTTP.StasuCK之类的常数，则需要这样做。
import "net/http"1快速开始让我们先通过一个简单的例子，迅速的了解以下以下demo代码摘自Gin的github实例
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()}1234567891011通过$ go run quick.go 启动然后浏览器输入http://0.0.0.0:8080/ping浏览器会渲染输出为：{"message":"pong"}
当然我们还可以利用如下的方式，渲染浏览器页面输出字符串
package main
import ("github.com/gin-gonic/gin""net/http")func main() {router := gin.Default()
router.GET("/someGet", getting)router.Run()}func getting(c *gin.Context){c.String(http.StatusOK,"Hello gin")}
12345678910111213141516浏览器会渲染输出为：Hello gin
我们点开源码发现，不管是渲染输出json格式、还是简单的字符串都是调用了c.Render方法，以下只是列出了2种，还有其他的诸如HTML、IndentedJSON、SecureJSON、JSONP、AsciiJSON、XML、YAML、ProtoBuf等
func (c *Context) String(code int, format string, values ...interface{}) {c.Render(code, render.String{Format: format, Data: values})}123func (c *Context) JSON(code int, obj interface{}) {c.Render(code, render.JSON{Data: obj})}123路径参数
func main() {router := gin.Default()
router.GET("/someGet/:name", getting)router.Run()}
func getting(c *gin.Context){name:=c.Param("name")c.String(http.StatusOK,"Hello%s",name)}
123456789101112131415以上函数的路由将会匹配 /user/john格式，但是不回匹配 /user/ 或者 /user所以我们浏览器输入http://0.0.0.0:8080/someGet/aaaa可以http://0.0.0.0:8080/someGet/或者http://0.0.0.0:8080/someGet都报错误
以上是一个参数，我们还可以定义多级参数，例如下面的例子：
以上的路由函数可以匹配 /user/john/ 或者 /user/john/send但是不会匹配 /user/john, 报异常例如浏览器输入http://0.0.0.0:8080/someGet/aaaa/，页面输出Helloaaaa-/例如浏览器输入http://0.0.0.0:8080/someGet/aaaa/gg,页面输出Helloaaaa-/gg例如浏览器输入http://0.0.0.0:8080/someGet/aaaa/gg/cc，页面输出Helloaaaa-/gg/cc但是浏览器输入http://0.0.0.0:8080/someGet/aaaa，报异常404 page not found
构造参数我们除了可以获取路径参数，还可以获取构造的参数，我们看下面的例子
func main() {router := gin.Default()
router.GET("/someGet", getting)router.Run()}
func getting(c *gin.Context){firstname := c.DefaultQuery("firstname", "Guest")lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
c.String(http.StatusOK, "Hello %s %s", firstname, lastname)}1234567891011121314浏览器输入http://0.0.0.0:8080/someGet?firstname=wyf&lastname=123渲染页面输出为Hello wyf 123
浏览器输入http://0.0.0.0:8080/someGet?lastname=123，渲染页面输出为Hello Guest 123
post传参这里为利用了postman进行演示操作
func main() {router := gin.Default()
router.POST("/someGet", getting)router.Run()}
func getting(c *gin.Context){message := c.PostForm("message")nick := c.DefaultPostForm("nick", "anonymous")
c.JSON(200, gin.H{"status": "posted","message": message,"nick": nick,})}123456789101112131415161718效果图如下：
get+post混合形式
func main() {router := gin.Default()
router.POST("/someGet", getting)router.Run()}
func getting(c *gin.Context){
id := c.Query("id")page := c.DefaultQuery("page", "0")name := c.PostForm("name")message := c.PostForm("message")
c.String(http.StatusOK,"id: %s; page: %s; name: %s; message: %s", id, page, name, message)}
12345678910111213141516171819效果图如下：
构造Map格式这样的格式以前我还没见过，感觉挺新鲜的，看下代码
func main() {router := gin.Default()
router.POST("/someGet", getting)router.Run()}
func getting(c *gin.Context){ids := c.QueryMap("ids")names := c.PostFormMap("names")
fmt.Printf("ids: %v; names: %v", ids, names)c.JSON(200,gin.H{"ids":ids,"names":names,})c.String(http.StatusOK,"ids: %v; names: %v", ids, names)}
12345678910111213141516171819202122fmt输出如下：
ids: map[b:hello a:1234]; names: map[first:thinkerou second:tianou]1效果图如下：
分组路由我们还可以进行路由分组设置，看下面的例子
package main
import ("fmt""github.com/gin-gonic/gin")
func main() {router := gin.Default()
v1 := router.Group("/v1"){v1.GET("/read", readEndpoint)}
v2 := router.Group("/v2"){v2.GET("/login", loginEndpoint)}
router.Run(":8080")}
func readEndpoint(c *gin.Context) {fmt.Println("read")
}
func loginEndpoint(c *gin.Context) {fmt.Println("login")}12345678910111213141516171819202122232425262728293031323334浏览器输入http://127.0.0.1:8080/v1/read后台log输出read
浏览器输入http://127.0.0.1:8080/v2/login后台log输出login————————————————版权声明：本文为CSDN博主「丙申」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/u013210620/java/article/details/82773905
来源：oschina
链接：https://my.oschina.net/u/4283847/blog/4290685