快速入门

第一个demo

  1. func main() {
  2.     r := gin.Default()
  3.     r.GET("/ping", func(c *gin.Context) {
  4.         c.JSON(200, gin.H{
  5.             "msg": "pong",
  6.         })
  7.     })
  9.     r.Run(":8777")
  10. }

使用get、post、put等http方法

  1. func main() {
  2.     // 使用默认中间件创建一个gin路由器
  3.     // logger and recovery (crash-free) 中间件
  4.     router := gin.Default()
  6.     router.GET("/someGet", getting)
  7.     router.POST("/somePost", posting)
  8.     router.PUT("/somePut", putting)
  9.     router.DELETE("/someDelete", deleting)
  10.     router.PATCH("/somePatch", patching)
  11.     router.HEAD("/someHead", head)
  12.     router.OPTIONS("/someOptions", options)
  14.     // 默认启动的是 8080端口，也可以自己定义启动端口
  15.     router.Run()
  16.     // router.Run(":3000") for a hard coded port
  17. }

URL和路由分组

路由分组

  1. func main() {
  2.     router := gin.Default()
  3.     // Simple group: v1
  4.     v1 := router.Group("/v1")
  5.     {
  6.         v1.POST("/login", loginEndpoint)
  7.         v1.POST("/submit", submitEndpoint)
  8.         v1.POST("/read", readEndpoint)
  9.     }
  10.     // Simple group: v2
  11.     v2 := router.Group("/v2")
  12.     {
  13.         v2.POST("/login", loginEndpoint)
  14.         v2.POST("/submit", submitEndpoint)
  15.         v2.POST("/read", readEndpoint)
  16.     }
  17.     router.Run(":8777")
  18. }

带参数的url

  1. func main() {
  2.     r := gin.Default()
  4.     goodsGroup := r.Group("/goods")
  5.     {
  6.         goodsGroup.GET("", goodsList)
  7.         goodsGroup.GET("/:id/:action", goodsDetail)
  8.         //goodsGroup.GET("/:id/*action", goodsDetail)
  9.         goodsGroup.POST("", createGoods)
  10.     }
  12.     r.Run(":8777")
  13. }
  15. func goodsList(c *gin.Context) {
  16.     c.JSON(http.StatusOK, gin.H{
  17.         "name": "list",
  18.     })
  19. }
  21. func goodsDetail(c *gin.Context) {
  22.     id := c.Param("id")
  23.     action := c.Param("action")
  24.     c.JSON(http.StatusOK, gin.H{
  25.         "id":     id,
  26.         "action": action,
  27.     })
  28. }
  30. func createGoods(c *gin.Context) {
  32. }

获取路由分组的参数

  1. type Person struct {
  2.     ID   int    `uri:"id" binding:"required"`
  3.     Name string `uri:"name" binding:"required"`
  4. }
  6. func main() {
  7.     r := gin.Default()
  9.     r.GET("/:name/:id", func(c *gin.Context) {
  10.         var person Person
  11.         if err := c.ShouldBindUri(&person); err != nil {
  12.             c.Status(404)
  13.             return
  14.         }
  15.         c.JSON(http.StatusOK, gin.H{
  16.             "name": person.Name,
  17.             "id":   person.ID,
  18.         })
  19.     })
  21.     r.Run(":8777")
  22. }

获取参数

获取get /post参数

  1. func main() {
  2.     r := gin.Default()
  3.     r.GET("/welcome", welcome)
  4.     r.POST("/formPost", formPost)
  5.     r.Run(":8777")
  6. }
  8. func welcome(c *gin.Context) {
  9.     firstname := c.DefaultQuery("first", "lcd")
  10.     lastname := c.DefaultQuery("last", "qq")
  11.     c.JSON(http.StatusOK, gin.H{
  12.         "f": firstname,
  13.         "l": lastname,
  14.     })
  15. }
  17. func formPost(c *gin.Context) {
  18.     msg := c.PostForm("msg")
  19.     nick := c.DefaultPostForm("nick", "anonymous")
  20.     c.JSON(http.StatusOK, gin.H{
  21.         "msg":  msg,
  22.         "nick": nick,
  23.     })
  24. }

JSON、ProtoBuf 渲染

输出json和protobuf

  1. syntax = "proto3";
  2. option go_package = ".;proto";
  4. message Teacher {
  5.     string name = 1;
  6.     repeated string course = 2;
  7. }
  1. func main() {
  2.     r := gin.Default()
  3.     // gin.H is a shortcut for map[string]interface{}
  4.     r.GET("/someJSON", func(c *gin.Context) {
  5.         c.JSON(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
  6.     })
  7.     r.GET("/moreJSON", func(c *gin.Context) {
  8.         // You also can use a struct
  9.         var msg struct {
  10.             Name    string `json:"user"`
  11.             Message string
  12.             Number  int
  13.         }
  14.         msg.Name = "Lena"
  15.         msg.Message = "hey"
  16.         msg.Number = 123
  17.         // Note that msg.Name becomes "user" in the JSON
  18.         // Will output  :   {"user": "Lena", "Message": "hey", "Number": 123}
  19.         c.JSON(http.StatusOK, msg)
  20.     })
  22.     r.GET("/someProtoBuf", func(c *gin.Context) {
  23.         courses := []string{"python", "django", "go"}
  24.         // The specific definition of protobuf is written in the testdata/protoexample file.
  25.         data := &proto.Teacher{
  26.             Name: "lll",
  27.             Course:  courses,
  28.         }
  29.         // Note that data becomes binary data in the response
  30.         // Will output protoexample.Test protobuf serialized data
  31.         c.ProtoBuf(http.StatusOK, data)
  32.     })
  34.     r.Run(":8777")
  35. }

pureJSON

通常情况下，JSON会将特殊的HTML字符替换为对应的unicode字符，比如<替换为\u003c，如果想原样输出html，则使用PureJSON 
  1. func main() {
  2.     r := gin.Default()
  4.     // Serves unicode entities
  5.     r.GET("/json", func(c *gin.Context) {
  6.         c.JSON(200, gin.H{
  7.             "html": "<b>Hello, world!</b>",
  8.         })
  9.     })
  11.     // Serves literal characters
  12.     r.GET("/purejson", func(c *gin.Context) {
  13.         c.PureJSON(200, gin.H{
  14.             "html": "<b>Hello, world!</b>",
  15.         })
  16.     })
  18.     r.Run(":8777")
  19. }

表单验证

表单的基本验证（登录注册）

Gin使用 go-playground/validator 验证参数，查看完整文档。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "reflect"
  7.     "strings"
  9.     "github.com/go-playground/locales/en"
  10.     ut "github.com/go-playground/universal-translator"
  11.     en_translations "github.com/go-playground/validator/v10/translations/en"
  12.     zh_translations "github.com/go-playground/validator/v10/translations/zh"
  14.     "github.com/go-playground/locales/zh"
  16.     "github.com/gin-gonic/gin/binding"
  17.     "github.com/go-playground/validator/v10"
  19.     "github.com/gin-gonic/gin"
  20. )
  22. var trans ut.Translator
  24. type Login struct {
  25.     User     string ` json:"user" binding:"required,min=3" `
  26.     Password string ` json:"password" binding:"required"`
  27. }
  29. type SignUp struct {
  30.     Age        uint8  `json:"age" binding:"gte=1,lte=130"`
  31.     Name       string `json:"name" binding:"required"`
  32.     Email      string `json:"email" binding:"required,email"`
  33.     Password   string `json:"password" binding:"required"`
  34.     RePassword string `json:"re_password" binding:"required,eqfield=Password"`
  35. }
  37. func RemoveTopStruct(fields map[string]string) map[string]string {
  38.     rsp := map[string]string{}
  39.     for field, err := range fields {
  40.         rsp[field[strings.Index(field, ".")+1:]] = err
  41.     }
  42.     return rsp
  43. }
  45. func InitTrans(locale string) (err error) {
  46.     if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
  47.         v.RegisterTagNameFunc(func(field reflect.StructField) string {
  48.             name := strings.SplitN(field.Tag.Get("json"), ",", 2)[0]
  49.             if name == "-" {
  50.                 return ""
  51.             }
  52.             return name
  53.         })
  54.         zhT := zh.New()
  55.         enT := en.New()
  56.         uni := ut.New(enT, zhT, enT)
  57.         trans, ok = uni.GetTranslator(locale)
  58.         if !ok {
  59.             return fmt.Errorf("uni.GetTranslator(%s)", locale)
  60.         }
  62.         switch locale {
  63.         case "en":
  64.             en_translations.RegisterDefaultTranslations(v, trans)
  65.         case "zh":
  66.             zh_translations.RegisterDefaultTranslations(v, trans)
  67.         default:
  68.             en_translations.RegisterDefaultTranslations(v, trans)
  69.         }
  70.         return
  71.     }
  72.     return
  73. }
  75. func main() {
  76.     if err := InitTrans("zh"); err != nil {
  77.         fmt.Println("初始化翻译器错误")
  78.         return
  79.     }
  80.     r := gin.Default()
  81.     r.POST("/loginJSON", func(c *gin.Context) {
  82.         var login Login
  83.         if err := c.ShouldBind(&login); err != nil {
  84.             fmt.Println(err.Error())
  85.             c.JSON(http.StatusBadRequest, gin.H{
  86.                 "error": err.Error(),
  87.             })
  88.             return
  89.         }
  90.         c.JSON(http.StatusOK, gin.H{
  91.             "msg": "login success",
  92.         })
  93.     })
  95.     r.POST("/signUp", func(c *gin.Context) {
  96.         var signUp SignUp
  97.         if err := c.ShouldBind(&signUp); err != nil {
  98.             errs, ok := err.(validator.ValidationErrors)
  99.             if !ok {
  100.                 c.JSON(http.StatusOK, gin.H{
  101.                     "msg": err.Error(),
  102.                 })
  103.                 return
  104.             }
  105.             c.JSON(http.StatusBadRequest, gin.H{
  106.                 "error": RemoveTopStruct(errs.Translate(trans)),
  107.             })
  108.             return
  109.         }
  110.         c.JSON(http.StatusOK, gin.H{
  111.             "msg": "signUp success",
  112.         })
  113.     })
  114.     r.Run(":8777")
  115. }
测试 
  1. import requests
  2. #login
  3. resp = requests.post("http://127.0.0.1:8777/loginJSON", json={
  4.    "user": "xdd",
  5.    "password": "1233"
  6. })
  8. print(resp.text)
  1. import requests
  2. #signUp
  3. resp = requests.post("http://127.0.0.1:8777/signUp", json={
  4.    "age": 18,
  5.    "name": "xdd",
  6.    "email": "12@qq.com",
  7.    "password": "aaa",
  8.    "re_password": "aaa",
  10. })
  12. print(resp.text)

中间件和next函数

Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（Hook）函数。这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等。

默认启动

  1. // 默认启动方式，包含 Logger、Recovery 中间件
  2. r := gin.Default()

使用中间件

  1. func main() {
  2.     // 创建一个不包含中间件的路由器
  3.     r := gin.New()
  5.     // 全局中间件
  6.     // 使用 Logger 中间件
  7.     r.Use(gin.Logger())
  9.     // 使用 Recovery 中间件
  10.     r.Use(gin.Recovery())
  12.     // 路由添加中间件，可以添加任意多个
  13.     r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
  15.     // 路由组中添加中间件
  16.     // authorized := r.Group("/", AuthRequired())
  17.     // exactly the same as:
  18.     authorized := r.Group("/")
  19.     // per group middleware! in this case we use the custom created
  20.     // AuthRequired() middleware just in the "authorized" group.
  21.     authorized.Use(AuthRequired())
  22.     {
  23.         authorized.POST("/login", loginEndpoint)
  24.         authorized.POST("/submit", submitEndpoint)
  25.         authorized.POST("/read", readEndpoint)
  27.         // nested group
  28.         testing := authorized.Group("testing")
  29.         testing.GET("/analytics", analyticsEndpoint)
  30.     }
  32.     // Listen and serve on 0.0.0.0:8080
  33.     r.Run(":8080")
  34. }

自定义组件

  1. func main() {
  2.     r := gin.New()
  3.     r.Use(Logger())
  4.     r.GET("/test", func(c *gin.Context) {
  5.         example := c.MustGet("example").(string)
  6.         log.Println(example)
  7.     })
  8.     r.Run(":8777")
  9. }
  11. func Logger() gin.HandlerFunc {
  12.     return func(c *gin.Context) {
  13.         t := time.Now()
  14.         c.Set("example", "123")
  15.         c.Next()
  17.         end := time.Since(t)
  18.         log.Println(end)
  19.         status := c.Writer.Status()
  20.         log.Println(status)
  21.     }
  22. }

通过c.abort()终止中间件后续逻辑的执行