gin框架学习笔记

pedestrian_h2025-04-27 16:17

Gin 是一个基于 Go 语言的高性能 Web 框架

gin下载

在已有的go项目直接终端输入

Go 复制代码 
go get -u github.com/gin-gonic/gin

hello world快速上手

Go 复制代码 
package main

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

func main() {
	router := gin.Default()
	router.GET("/", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "Hello world!",
		})
	})
	router.Run()
}

运行

Go 复制代码 
go run main.go

浏览器输入http://localhost:8080/

可以看到浏览器显示

到这里简单的gin上手完成了

参数获取

路径参数获取

这里可以类比Java springboot 的@RequestParam

即获取路径url？后边的参数数据

Go 复制代码 
func main() {
	r := gin.Default()
	r.GET("/user/phone", func(c *gin.Context) {
		//设置默认的数值 假设路径参数phone没有传值则给一个默认值
		phone := c.DefaultQuery("phone", "333")
        //直接获取路径参数
		username := c.Query("username")
        Json格式返回参数
		c.JSON(http.StatusOK, gin.H{
			"message":  "ok",
			"username": username,
			"phone":    phone,
		})
	})
	r.Run()
}

浏览器输入user/phone?phone=333&username=用户

浏览器输入user/phone?username=用户

路径参数没有给phone的参数

这里给出了默认的返回333

这里的返回是由于gin程序里 phone := c.DefaultQuery("phone", "333")实现的

form参数获取

Go 复制代码 
func main() {
	//Default返回一个默认的路由引擎
	r := gin.Default()
	r.POST("/user/phone", func(c *gin.Context) {
		// DefaultPostForm取不到值时会返回指定的默认值
		username := c.DefaultPostForm("username", "用户")
		// username := c.PostForm("username")
		phone := c.PostForm("phone")
		c.JSON(http.StatusOK, gin.H{
			"message":  "ok",
			"username": username,
			"phone":    phone,
		})
	})
	r.Run(":8080")
}

postman调试（参数都有传值）

返回

postman调试（username参数没有传值）

返回默认值 "用户"

这里实现和获取默认路径差不多 username := c.DefaultPostForm("username", "用户")

调用DefaultPostForm实现的

json参数获取

这里可以类比Java的@RequestBody

如下程序实现了把给定的json参数原样返回

Go 复制代码 
func main() {
	r := gin.Default()
	r.POST("/json", func(c *gin.Context) {
		b, err := c.GetRawData() // 从c.Request.Body读取请求数据
		if err != nil {
			log.Fatal(err)
		}
		var m map[string]interface{}
		// 反序列化
		err1 := json.Unmarshal(b, &m)
		if err1 != nil {
			log.Fatal(err1)

		}
		c.JSON(http.StatusOK, m)
	})

	r.Run(":8080")
}

postman调用

返回

path参数获取

可以类比成Java的@PathVariable

Go 复制代码 
func main() {
	r := gin.Default()
	r.GET("/user/phone/:username/:phone", func(c *gin.Context) {
		username := c.Param("username")
		phone := c.Param("phone")
		//输出json结果给调用方
		c.JSON(http.StatusOK, gin.H{
			"message":  "ok",
			"username": username,
			"phone":    phone,
		})
	})

	r.Run(":8080")
}

postman调用

传格式如下

/user/phone/测试用户参数/10190010933

返回

参数绑定

即利用反射机制，通过请求的Content-Type以及ShouldBind函数自动判断请求的格式来解析出来再绑定到返回的数据中，这里就和springboot的@RequestParam等注解自动解析差不多

Go 复制代码 
type Login struct {
	User     string `form:"user" json:"user" binding:"required"`
	Password string `form:"password" json:"password" binding:"required"`
}

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

	// 绑定JSON的示例 ({"user": "q1mi", "password": "123456"})
	router.POST("/loginJSON", func(c *gin.Context) {
		var login Login

		if err := c.ShouldBind(&login); err == nil {
			fmt.Printf("login info:%#v\n", login)
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})

	// 绑定form表单示例 (user=q1mi&password=123456)
	router.POST("/loginForm", func(c *gin.Context) {
		var login Login
		// ShouldBind()会根据请求的Content-Type自行选择绑定器
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})

	// 绑定QueryString示例 (/loginQuery?user=q1mi&password=123456)
	router.GET("/loginQuery", func(c *gin.Context) {
		var login Login
		// ShouldBind()会根据请求的Content-Type自行选择绑定器
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})

	// Listen and serve on 0.0.0.0:8080
	router.Run(":8080")
}

json格式

返回

form格式

返回

query格式

返回

文件上传

单文件上传

Go 复制代码 
func main() {
	router := gin.Default()
	// 处理multipart forms提交文件时默认的内存限制是32 MiB
	// 可以通过下面的方式修改
	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
	router.POST("/upload", func(c *gin.Context) {
		// 单个文件
		file, err := c.FormFile("f1")
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{
				"message": err.Error(),
			})
			return
		}

		log.Println(file.Filename)
		dst := fmt.Sprintf("/Users/kanyu/Desktop/project/kanyu_server/ginlearn/templates/user/%s", file.Filename)
		// 上传文件到指定的目录
		c.SaveUploadedFile(file, dst)
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("'%s' uploaded!", file.Filename),
		})
	})
	router.Run()
}

原项目结构

postman上传文件

结果

可以看到文件上传成功 目录下多了个3.zip文件

多文件上传

Go 复制代码 
func main() {
	router := gin.Default()
	// 处理multipart forms提交文件时默认的内存限制是32 MiB
	// 可以通过下面的方式修改
	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
	router.POST("/upload", func(c *gin.Context) {
		// Multipart form
		form, _ := c.MultipartForm()
		//取key=file的参数文件
		files := form.File["file"]

		for index, file := range files {
			log.Println(file.Filename)
			dst := fmt.Sprintf("/Users/kanyu/Desktop/project/kanyu_server/ginlearn/templates/user/_%d_%s", index, file.Filename)
			// 上传文件到指定的目录
			c.SaveUploadedFile(file, dst)
		}
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("%d files uploaded!", len(files)),
		})
	})
	router.Run()
}

原项目结构

postman调用多文件上传

返回

项目结构

路由

常规路由

Go 复制代码 
router.GET("/", func(c *gin.Context) {}

router.POST("/", func(c *gin.Context) {}

router.GET("/", func(c *gin.Context) {}

这些路由在之前参数获取的时候讲过了

和java中差不多 根据请求类型和路径的不同获取请求的参数进行处理

Any

Go 复制代码 
func main() {
	router := gin.Default()
	router.Any("/", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "Hello world!",
		})
	})

	router.Run()
}

get请求

post请求

可以看到无论请求类型如何 都会返回程序中定义的"Hello world!"

NoRoute

即无路由请求传任何路径的返回处理

Go 复制代码 
func main() {
	router := gin.Default()
	router.NoRoute(func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "404 Not Found",
		})
	})

	router.Run()
}

给定任意路径

路由组

相当于Java springboot的如下结构 利用@RestController和@RequestMapping("/chat")

都拥有共同的前缀/chat

所以拥有共同的前缀url划分为路由组

Go 复制代码 
func main() {
	r := gin.Default()
	userGroup := r.Group("/user")
	{
		userGroup.GET("/index", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"message": "user index",
			})
		})
		userGroup.GET("/login", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"message": "user login GET",
			})
		})
		userGroup.POST("/login", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"message": "user login POST",
			})
		})

	}
	shopGroup := r.Group("/shop")
	{
		shopGroup.GET("/index", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"message": "shop login",
			})
		})
		shopGroup.GET("/cart", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"message": "shop cart",
			})
		})
		shopGroup.POST("/checkout", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"message": "shop checkout",
			})
		})
		// 嵌套路由组
		shouIndexGroup := shopGroup.Group("/index")
		shouIndexGroup.GET("/router", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"message": "shop index router",
			})
		})

	}
	r.Run()
}

请求/user/index

请求GET /user/login

请求POST /user/login

请求/shop/index

请求/shop/cart

请求/shop/checkout

嵌套路由 请求/shop/index/router

中间件

专注于HTTP请求处理流程的拦截与扩展，如日志记录、权限验证、异常恢复等。其核心是通过链式调用模式对单个请求生命周期进行功能增强，属于轻量级、高并发的Web开发组件，

比如Gin默认中间件gin.Logger()用于请求日志记录，gin.Recovery()用于panic恢复

gin框架的中间件类比Java

如Spring Interceptor的preHandle()和postHandle()方法，与Gin中间件的请求前后逻辑对应，适合权限检查、参数预处理等场景

如Java Servlet Filter均通过链式调用（Chain of Responsibility模式）拦截HTTP请求，可在请求处理前、后插入逻辑

定义中间件和注册

Go 复制代码 
func StatCost() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		c.Set("name", "小王子") // 可以通过c.Set在请求上下文中设置值，后续的处理函数能够取到该值
		// 调用该请求的剩余处理程序
		c.Next()
		// 不调用该请求的剩余处理程序
		// c.Abort()
		// 计算耗时
		cost := time.Since(start)
		log.Println(cost)
	}
}

// 全局注册路由
func main() {
	// 新建一个没有任何默认中间件的路由
	r := gin.New()
	// 注册一个全局中间件
	r.Use(StatCost())

	r.GET("/test", func(c *gin.Context) {
		name := c.MustGet("name").(string) // 从上下文取值
		log.Println(name)
		c.JSON(http.StatusOK, gin.H{
			"message": "Hello " + name,
		})
	})
	r.Run()
}

调用/test

可以看到返回了中间件前置处理塞进去的值 "小王子"

这里利用c.MustGet("name").(string)取到了上下文数值，底层利用了Context的能力，这个后续再记录下Context的核心实现和原理

单个路由注册中间件

Go 复制代码 
func StatCost() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		c.Set("name", "小王子") // 可以通过c.Set在请求上下文中设置值，后续的处理函数能够取到该值
		// 调用该请求的剩余处理程序
		c.Next()
		// 不调用该请求的剩余处理程序
		// c.Abort()
		// 计算耗时
		cost := time.Since(start)
		log.Println(cost)
	}
}

//记录响应体中间件

type bodyLogWriter struct {
	gin.ResponseWriter               // 嵌入gin框架ResponseWriter
	body               *bytes.Buffer // 我们记录用的response
}

// Write 写入响应体数据
func (w bodyLogWriter) Write(b []byte) (int, error) {
	w.body.Write(b)                  // 我们记录一份
	return w.ResponseWriter.Write(b) // 真正写入响应
}

// ginBodyLogMiddleware 一个记录返回给客户端响应体的中间件
// https://stackoverflow.com/questions/38501325/how-to-log-response-body-in-gin
func ginBodyLogMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		blw := &bodyLogWriter{body: bytes.NewBuffer([]byte{}), ResponseWriter: c.Writer}
		c.Writer = blw // 使用我们自定义的类型替换默认的

		c.Next() // 执行业务逻辑

		fmt.Println("Response body: " + blw.body.String()) // 事后按需记录返回的响应
	}
}

func main() {
	// 新建一个没有任何默认中间件的路由
	r := gin.New()
	// 注册两个中间件 一个记录耗时 一个记录响应体 这里可以注册多个中间件
	r.GET("/test", StatCost(), ginBodyLogMiddleware(), func(c *gin.Context) {
		name := c.MustGet("name").(string) // 从上下文取值
		log.Println(name)
		c.JSON(http.StatusOK, gin.H{
			"message": "Hello " + name,
		})
	})
	r.Run()
}

请求

后台打印日志

可以看到后台打印出了相应体 Response body: {"message":"Hello 小王子"}

以及耗时209.369

参考：

李文周go语言教程

相关推荐
每次的天空1 小时前
Android学习总结之Room篇
android·学习·oracle
白泽来了1 小时前
2个小时1.5w字｜ React & Golang 全栈微服务实战
笔记·go·react
丶Darling.2 小时前
26考研 | 王道 | 数据结构笔记博客总结
数据结构·笔记·考研
道长没有道观2 小时前
计算机操作系统笔记
笔记·考研·操作系统
Nuyoah.2 小时前
《Vue3学习手记5》
前端·javascript·学习
一点.点4 小时前
李沐动手深度学习（pycharm中运行笔记）——04.数据操作
pytorch·笔记·python·深度学习·pycharm·动手深度学习
陶然同学5 小时前
RabbitMQ全栈实践手册：从零搭建消息中间件到SpringAMQP高阶玩法
java·分布式·学习·rabbitmq·mq
欧先生^_^6 小时前
学习 Apache Kafka
学习·kafka·apache
妙极矣7 小时前
JAVAEE初阶01
java·学习·java-ee
娃娃略7 小时前
【AI模型学习】双流网络——更强大的网络设计
网络·人工智能·pytorch·python·神经网络·学习
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04西电B测-计算机网络综合实验(含验收问题)05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09苍穹外卖面试总结10Vue3实现优雅的前端版本更新提示