1. 数据渲染
1.1 各种数据格式的响应
- json、结构体、XML、YAML类似于java的properties、ProtoBuf
1.1.1 返回JSON
json
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
r := gin.Default()
r.POST("/demo", func(res *gin.Context) {
res.JSON(http.StatusOK, gin.H{
"message": "success",
})
})
r.Run(":8080")
}
1.1.2 返回结构体
go
r.GET("/demo", func(res *gin.Context) {
var obj struct {
name string
age int8
}
obj.age = 1
obj.name = "张三"
res.JSON(http.StatusOK, obj)
})
1.1.3 XML 和 YAML
go
// 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"})
})
1.1.4 浅浅扒一下源码
进入res.JSON函数里面看一下
go
res.JSON(http.StatusOK, obj)
go
func (c *Context) JSON(code int, obj any) {
c.Render(code, render.JSON{Data: obj})
}
- (c *Context) 代表可以被Context类型调用
- (code int, obj any) 传入参数,状态码和返回对象
它本身内部再次封装了一层提供给Render类型
go
func (c *Context) Render(code int, r render.Render) {
c.Status(code)
if !bodyAllowedForStatus(code) {
r.WriteContentType(c.Writer)
c.Writer.WriteHeaderNow()
return
}
if err := r.Render(c.Writer); err != nil {
// Pushing error to c.Errors
_ = c.Error(err)
c.Abort()
}
}
进入Render里面,可以看到
- (code int, r render.Render) 参数进行了更改,传入了render包下的Render类型
可以看一下Render这个接口
go
type Render interface {
// Render writes data with custom ContentType.
Render(http.ResponseWriter) error
// WriteContentType writes custom ContentType.
WriteContentType(w http.ResponseWriter)
}
接口还提供了一个可以修改ContentType的方法
go
if !bodyAllowedForStatus(code) {
r.WriteContentType(c.Writer)
c.Writer.WriteHeaderNow()
return
}
- bodyAllowedForStatus()进行了判断
go
func bodyAllowedForStatus(status int) bool {
switch {
case status >= 100 && status <= 199:
return false
case status == http.StatusNoContent:
return false
case status == http.StatusNotModified:
return false
}
return true
}
判断了传入的状态码是否符合正确的状态码,并返回
-
当bodyAllowedForStatus()判断为错误状态码时
会在返回对象中写入ContentType内容
c.Writer.WriteHeaderNow()还会写入文本流中
再看一下其他返回的类型;例如XML
go
func (c *Context) XML(code int, obj any) {
c.Render(code, render.XML{Data: obj})
}
在内部封装时,只是标注了不同的render类型
1.2 重定向
访问/demo地址时,将页面重定向跳转至其他页面
go
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
r := gin.Default()
r.GET("/demo", func(c *gin.Context) {
c.Redirect(http.StatusMovedPermanently, "http://www.baidu.com")
})
r.Run(":8080")
}
2. 中间件
2.1 全局中间件
- 所有请求都经过此中间件
go
package main
import (
"github.com/gin-gonic/gin"
"log"
"time"
)
func MiddleWare() gin.HandlerFunc {
return func(c *gin.Context) {
t := time.Now()
log.Println("中间件开始运行:", t)
c.Set("middle_1", "中间件1执行结束")
status := c.Writer.Status()
log.Println("中间件执行结束:", status)
t2 := time.Since(t)
log.Println("耗时:", t2)
}
}
func main() {
r := gin.Default()
// 注册中间件
r.Use(MiddleWare())
r.GET("/demo", func(c *gin.Context) {
// 获得内容
m, _ := c.Get("middle_1")
log.Println("中间件接收参数:", m)
c.JSON(200, gin.H{"中间件接收参数:": m})
})
r.Run(":8080")
}
测试:http://localhost:8080/demo
返回结果:
bash
[GIN-debug] Listening and serving HTTP on :8080
2025/04/29 00:12:34 中间件开始运行: 2025-04-29 00:12:34.5992889 +0800 CST m=+1.770059901
2025/04/29 00:12:34 中间件执行结束: 200
2025/04/29 00:12:34 耗时: 11.5258ms
2025/04/29 00:12:34 中间件接收参数: 中间件1执行结束
[GIN] 2025/04/29 - 00:12:34 | 200 | 11.5258ms | ::1 | GET "/demo"
gin 使用r.Use()来注册一个组件
- 在注册组件时,我们需要规定函数的返回类型,这才能让gin知道这是什么组件
go
func MiddleWare() gin.HandlerFunc {
return func(c *gin.Context) {
t := time.Now()
log.Println("中间件开始运行:", t)
c.Set("middle_1", "中间件1执行结束")
status := c.Writer.Status()
log.Println("中间件执行结束:", status)
t2 := time.Since(t)
log.Println("耗时:", t2)
}
}
- 这里MiddleWare()函数规定了返回类型是
gin.HandlerFunc
,这就代表这个函数是一个处理类
2.1.1 Next() 方法
我们在正常注册中间件时,会打断原有的运行流程,但是你可以在中间件函数内部添加Next()方法,这样可以让原有的运行流程继续执行,当原有的运行流程结束后再回来执行中间件内部的内容
go
package main
import (
"github.com/gin-gonic/gin"
"log"
"time"
)
func MiddleWare() gin.HandlerFunc {
return func(c *gin.Context) {
t := time.Now()
log.Println("中间件开始运行:", t)
// 开启正常执行流程
c.Next()
c.Set("middle_1", "中间件1执行结束")
status := c.Writer.Status()
log.Println("中间件执行结束:", status)
t2 := time.Since(t)
log.Println("耗时:", t2)
}
}
func main() {
r := gin.Default()
// 注册中间件
r.Use(MiddleWare())
r.GET("/demo", func(c *gin.Context) {
// 获得内容
m, _ := c.Get("middle_1")
log.Println("中间件接收参数:", m)
c.JSON(200, gin.H{"中间件接收参数:": m})
})
r.Run(":8080")
}
测试:http://localhost:8080/demo
返回结果:
bash
[GIN-debug] Listening and serving HTTP on :8080
2025/04/29 00:14:14 中间件开始运行: 2025-04-29 00:14:14.5697461 +0800 CST m=+2.981609901
2025/04/29 00:14:14 中间件接收参数: <nil>
2025/04/29 00:14:14 中间件执行结束: 200
2025/04/29 00:14:14 耗时: 14.0262ms
[GIN] 2025/04/29 - 00:14:14 | 200 | 14.0262ms | ::1 | GET "/demo"
可以看到使用next后,正常执行流程中并没有获得到中间件设置的值
2.2 局部中间件
go
package main
import (
"github.com/gin-gonic/gin"
"log"
"time"
)
func MiddleWare() gin.HandlerFunc {
return func(c *gin.Context) {
t := time.Now()
log.Println("中间件开始运行:", t)
c.Set("middle_1", "中间件1执行结束")
status := c.Writer.Status()
log.Println("中间件执行结束:", status)
t2 := time.Since(t)
log.Println("耗时:", t2)
}
}
func main() {
r := gin.Default()
// 局部中间件-在为一个请求添加执行函数时即可挂载中间件
r.GET("/demo", MiddleWare(), func(c *gin.Context) {
// 获得内容
m, _ := c.Get("middle_1")
log.Println("中间件接收参数:", m)
c.JSON(200, gin.H{"中间件接收参数:": m})
})
r.Run(":8080")
}
- 为你想给哪一个请求挂载中间件,直接在对应的请求中添加中间件函数即可
3. ❤️GoGin框架------前文链接
Gin框架学习参考网站:gin框架·Go语言中文文档
- (Go Gin)基于Go的WEB开发框架,GO Gin是什么?怎么启动?本文给你答案
- (Go Gin)Gin学习笔记(二):路由配置、基本路由、表单参数、上传单个文件、上传多个文件、浅扒路由原理
(Go Gin)Gin学习笔记(三):数据解析和绑定,结构体分析,包括JSON解析、form解析、URL解析,区分绑定的Bind方法