1.路由（Route）

上一期到获取Query参数 这次从获取POST参数开始

POST参数

// POST  
r.POST("/form", func(c *gin.Context) {  
	username := c.PostForm("username")  
	password := c.DefaultPostForm("password", "000000") // 可设置默认值  
  
	c.JSON(http.StatusOK, gin.H{  
		"username": username,  
		"password": password,  
	})  
})

在控制台发送信息 这时候终端可以收到 这样一段信息

Query和POST混合参数

2.JSON

使用 AsciiJSON 生成具有转义的非 ASCII 字符的 ASCII-only JSON。

func main() {
	r := gin.Default()

	r.GET("student", func(c *gin.Context) {
		data := map[string]interface{}{
			"lang": "GO语言",
			"tag":  "<br>",
		}

		// 输出 : {"lang":"GO\u8bed\u8a00","tag":"\u003cbr\u003e"}
		c.AsciiJSON(http.StatusOK, data)
	})

	// 监听并在 0.0.0.0:8080 上启动服务
	r.Run(":8888")
}

编译结果

2.中间件

gin框架在请求处理的过程中，加入自己的钩子函数，这个钩子函数就叫中间件 middleWare 常常用于处理公共业务逻辑，如登录校验，耗时统计，日志打印等等

1.单个中间件

package main

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

// 定义中间件
func MiddleWare() gin.HandlerFunc {
	return func(c *gin.Context) {
	  fmt.Println("调用中间件")
	}
}

func main() {
    // 创建路由
    engine := gin.Default()

    // 注册中间件
    engine.Use(MiddleWare())

    // 路由规则
    engine.GET("/", func(c *gin.Context) {
        fmt.Println("调用路由处理函数")
        // 页面接收
        c.JSON(200, gin.H{"request": "使用中间件了"})
    })
    engine.Run(":8888")
}

当我们没有访问相关地址的时候终端上什么都没有 浏览器访问 终端显示 可见中间件已经被调用

2.多个中间件

gin支持同时使用多个中间件，并按照写入顺序依次执行

package main

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

// 定义中间件1
func MiddleWare1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件1")
    }
}

// 定义中间件2
func MiddleWare2() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件2")
    }
}

// 定义中间件3
func MiddleWare3() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件3")
    }
}
    
func main() {
    // 创建路由
    engine := gin.Default()

    // 注册中间件
    engine.Use(MiddleWare1(), MiddleWare2(), MiddleWare3())

    // 路由规则
    engine.GET("/", func(c *gin.Context) {
        fmt.Println("调用路由处理函数")
        // 页面接收
        c.JSON(200, gin.H{"request": "使用中间件了"})
    })

    engine.Run(":8888")
}

请求之前 请求之后 终端显示内容

3.中间件Abort()

中间件有两个重要的函数Abort和Next，Abort在被调用的函数中阻止后续中间件的执行，如输错了密码，调用Abort则其他的函数不会调用

调用示例

package main

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

// 定义中间件1
func MiddleWare1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件1")

        // 调用 Abort，终止执行后续的中间件
        c.Abort()
    }
}

// 定义中间件2
func MiddleWare2() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件2")
    }
}

// 定义中间件3
func MiddleWare3() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件3")
    }
}

func main() {
    // 创建路由
    engine := gin.Default()

    // 注册中间件
    engine.Use(MiddleWare1(), MiddleWare2(), MiddleWare3())

    // 路由规则
    engine.GET("/", func(c *gin.Context) {
        fmt.Println("调用路由处理函数")
        // 页面接收
        c.JSON(200, gin.H{"request": "Abort的使用"})
    })

    engine.Run()
}

很显然，上图的三个中间件中只有第一个会被调用，剩下的两个中间件会被阻止调用

4.中间件Next()

调用Next()，会将当前的中间件挂起，然后执行当前中间件之后的所有，最后返回执行未被执行完的中间件

package main

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

// 定义中间件1
func MiddleWare1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件1")

        // 调用 Next，开始执行后续的中间件
        c.Next()

        fmt.Println("中间件继续执行")
    }
}

// 定义中间件2
func MiddleWare2() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件2")
    }
}

// 定义中间件3
func MiddleWare3() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件3")
    }
}

func main() {
    // 创建路由
    engine := gin.Default()

    // 注册中间件
    engine.Use(MiddleWare1(), MiddleWare2(), MiddleWare3())

    // 路由规则
    engine.GET("/", func(c *gin.Context) {
        fmt.Println("调用路由处理函数")
        // 页面接收
        c.JSON(200, gin.H{"request": "Next的使用"})
    })
    engine.Run()
}

上面的执行顺序

调用中间件1
调用中间件2
调用中间件3
调用路由处理函数
中间件继续执行