gin

安装使用

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

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

路由传参

• 无参路由
• API参数
• URL参数

   package main

  import (
      "fmt"
      "github.com/gin-gonic/gin"
      "net/http"
  )

  func demoGin1(c *gin.Context) {
      c.String(http.StatusOK, "lalala")
  }

  func demoGin2(c *gin.Context) {
      // 通过param参数来获取方法
      Id := c.Param("id")
      c.String(http.StatusOK, fmt.Sprintf("id is %v", Id))
  }

  func demoGin3(c *gin.Context) {
      username := c.DefaultQuery("name", "xxx") //参数不存在，会返回默认值xxx
      username2 := c.Query("name")              // 参数不存在，就返回空字符串
      c.String(http.StatusOK, fmt.Sprintf("default query is:%#v \nquery is: %#v\n", username, username2))
  }

  func main() {
      r := gin.Default()
      r.GET("/lalala", demoGin1)   // 无参数路由 
      r.GET("/test/:id", demoGin2) // api 参数 
      r.GET("/query/", demoGin3)   // url 参数 
      r.Run(":8089")
  }
  

ShouldBind参数绑定

• 能够基于请求自动提取 JSON 、 form表单 和 QueryString 类型的数据，并把值绑定到指定的结构体对象。

   package main

  import (
      "fmt"
      "github.com/gin-gonic/gin"
      "net/http"
  )

  type Login struct {
      User     string `form:"user" json:"user" binding:"required"`
      Password string `form:"password" json:"password" binding:"required"`
  }

  func demoLogin(c *gin.Context) {
      var login Login
      //
      if err := c.ShouldBind(&login); err != nil {
          c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
      }
      c.String(http.StatusOK, fmt.Sprintf("姓名：%s -- 密码：%s", login.User, login.Password))
  }

  func main() {
      r := gin.Default()
      r.POST("/login/", demoLogin)
      r.Run(":8089")
  }
  

响应返回

• 响应String 用 c.String 来返回
• 响应json 用 c.Json 来返回值，也可以直接用 gin.H
• 响应Xml 用 c.XML 来返回
• 响应Yaml 用 c.YAML 来返回

   package main

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

  // 多种响应方式
  func main() {
      r := gin.Default()

      // 1.json
      r.GET("/someJSON", func(c *gin.Context) {
          c.JSON(200, gin.H{"message": "someJSON", "status": 200})
      })

      // 2. 结构体响应
      r.GET("/someStruct", func(c *gin.Context) {
          var msg struct {
              Name    string
              Message string
              Number  int
          }
          msg.Name = "root"
          msg.Message = "message"
          msg.Number = 123
          c.JSON(200, msg)
      })

      // 3.XML
      r.GET("/someXML", func(c *gin.Context) {
          c.XML(200, gin.H{"message": "abc"})
      })

      // 4.YAML响应
      r.GET("/someYAML", func(c *gin.Context) {
          c.YAML(200, gin.H{"name": "zhangsan"})
      })

      r.Run(":8089")
  }
  

路由重定向

• 用 c.Redirect 来重定向

   package main

  import (
      "net/http"
      "github.com/gin-gonic/gin"
  )

  func main() {
      r := gin.Default()
      r.GET("/", func(c *gin.Context) {
          c.Redirect(http.StatusMovedPermanently, "www.baidu.com")
      })
      r.Run()
  }
  

路由分发

• 路由拆分到多个文件

   demoGin3
  ├── go.mod
  ├── go.sum
  ├── main.go
  └── routers
      ├── user.go
      └── books.go
  

   // main.go

  package main

  import (
      "demoGin3/routes"
      "github.com/gin-gonic/gin"
  )

  func main() {
      r := gin.Default()
      routes.LoadBooks(r)
      routes.LoadUsers(r)

      r.Run(":8089")
  }
  

   // routes/books.go
  package routes

  import (
      "github.com/gin-gonic/gin"
      "net/http"
  )

  func LoadBooks(e *gin.Engine) {
      e.GET("/book", GetBookHandler)
  }

  func GetBookHandler(c *gin.Context) {
      c.JSON(http.StatusOK, gin.H{
          "message": "book route",
      })
  }
  

   // routes/user.go
  package routes

  import (
      "github.com/gin-gonic/gin"
      "net/http"
  )

  func LoadUsers(e *gin.Engine) {
      e.GET("/user", UserHandler)
  }

  func UserHandler(c *gin.Context) {
      c.JSON(http.StatusOK, gin.H{
          "message": "user route",
      })
  }
  

• 路由拆分到app

   gin_demo
  ├── app
  │   ├── app1
  │   │   ├── handler.go
  │   │   └── router.go
  │   └── app2
  │       ├── handler.go
  │       └── router.go
  ├── go.mod
  ├── go.sum
  ├── main.go
  └── routers
      └── routers.go
  

• routes.go 中用 include 来注册其他app中的路由， Init 来初始化

 type Option func(*gin.Engine)

var options = []Option{}

// 注册app的路由配置
func Include(opts ...Option) {
    options = append(options, opts...)
}

// 初始化
func Init() *gin.Engine {
    r := gin.Default()
    for _, opt := range options {
        opt(r)
    }
    return r
}  

• main.go 中注册路由，进行初始化

 func main() {
    // 加载多个APP的路由配置
    routers.Include(shop.Routers, blog.Routers)
    // 初始化路由
    r := routers.Init()
    if err := r.Run(); err != nil {
        fmt.Println("startup service failed, err:%v\n", err)
    }
}