路由

r.GET()
r.POST()
r.PUT()
r.PATCH()
r.DELETE()

路由分组

把一类api划分到一个组

可以给这个组加上统一的中间件

RESETFul Api规范

尽量使用名称的复数来定义路由,resetful只是一个api规范

// 在没有resetful规范正确，表示创建用户，删除用户
/api/user_create
/api/users/create
/api/users/add
/api/add_user
/api/user/delete
/api/user_remove

// 使用resetful规范
GET /api/users  用户列表
POST /api/users  创建用户
PUT /api/users/:id 更新用户信息
DELETE /api/users 批量删除用户
DELETE /api/users/:id 删除单个用户

中间件

局部中间件

直接作用于单个路由

package main

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

func Home(c *gin.Context) {
  fmt.Println("Home")
  c.String(200, "Home")
}
func M1(c *gin.Context) {
  fmt.Println("M1 请求部分")
  c.Next()
  fmt.Println("M1 响应部分")
}
func M2(c *gin.Context) {
  fmt.Println("M2 请求部分")
  c.Next()
  fmt.Println("M2 响应部分")
}

func main() {
  r := gin.Default()
  r.GET("", M1, M2, Home)
  r.Run(":8080")
}

可以使用Abort进行拦截，使用Abort拦截之后，会原路返回

全局中间件

全局也就是路由组。这也就是给路由分组的意义

package main

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

func Home(c *gin.Context) {
  fmt.Println("Home")
  c.String(200, "Home")
}
func M1(c *gin.Context) {
  fmt.Println("M1 请求部分")
  c.Abort()
  fmt.Println("M1 响应部分")
}
func M2(c *gin.Context) {
  fmt.Println("M2 请求部分")
  c.Next()
  fmt.Println("M2 响应部分")
}

func GM1(c *gin.Context) {
  fmt.Println("GM1 请求部分")
  c.Next()
  fmt.Println("GM1 响应部分")
}

func GM2(c *gin.Context) {
  fmt.Println("GM2 请求部分")
  c.Next()
  fmt.Println("GM2 响应部分")
}

func AuthMiddleware(c *gin.Context) {

}

func main() {
  r := gin.Default()
  g := r.Group("api")
  g.Use(GM1, GM2)
  g.GET("users", Home)
  r.Run(":8080")
}

中间件传递参数

c.Set("GM1", "GM1")
fmt.Println(c.Get("GM1"))