2. gin中间件注意事项、路由拆分与注册技巧

百里守约学编程2024-03-10 15:56

文章目录

一、中间件

在日常工作中，经常会有一些计算接口耗时和限流的操作，如果每写一个接口都需要手动的去加上计算耗时和限流的代码，显然是很冗余且不好维护的，还很容易遗漏。这个时候我们一般会想到使用中间件的方式，将这些与业务无关的代码写到中间件去，然后安到每个接口中去就行了。

go 复制代码 
package main

import (
	"fmt"
	"net/http"
	"time"

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

func timeMiddleware() gin.HandlerFunc {
	return func(ctx *gin.Context) {
		begin := time.Now()
		defer func() {
			fmt.Printf("use time %d ms\n", time.Since(begin).Milliseconds())
		}()
		ctx.Next()
	}
}


func limitMiddleware() gin.HandlerFunc {
	// 限流最高并发为10,这里return的func会必闭包使用这个limitChan，从而达到限流效果
	limitChan := make(chan struct{}, 10)  
	return func(ctx *gin.Context) {
		defer func() {
			<-limitChan
		}()
		limitChan <- struct{}{}
		
		ctx.Next()
	}
}

func bizHandler(ctx *gin.Context) {
	time.Sleep(100 * time.Millisecond)
	ctx.String(http.StatusOK, "gin 中间件")

}

func main() {
	engine := gin.Default()
	// Use方法就是将中间件放到了链条的首部，注意Use接收的是可变参数，可接收多个中间件
	// engine.Use(timeMiddleware(),limitMiddleware())
	// 如果是分别使用use，则要注意一下顺序，如这里将timeMiddleware后写，
	//是因为想把timeMiddleware放到链条首部，从而将限流中间件的耗时也统计到
	engine.Use(limitMiddleware())
	engine.Use(timeMiddleware())
	engine.GET("/v1", bizHandler)
	// engine.GET("/v2",timeMiddleware(), bizHandler)
	engine.Run("127.0.0.1:8080")
}

注意事项：

  1. 中间件是gin.HandlerFunc类型，在使用limitMiddleware和timeMiddleware时，我们加了小括号，因为它们的返回值才是gin.HandlerFunc类型
  2. engine.Get,engine.Post,engine.Use方法，接收的都是可变长参数，如示例中的v2路径，可以直接将中间件对指定的路径使用，或者用Use一次全局使用多个中间件
  3. 使用多个Use时，注意使用顺序，后使用的Use，里面的中间件会放到链表首部
  4. 如果中间件中没有使用ctx.Next,则是将当前中间件执行完后再去执行链表上的下一个handler，如果使用了ctx.Next则表示从此处开始，先将链表后面的handler都执行完，然后再回溯到这里的ctx.Next位置来，继续执行当前中间件函数中的后续代码。

二、Gin路由简介

1、普通路由

go 复制代码 
r.GET("/index", func(c *gin.Context) {...})
r.GET("/login", func(c *gin.Context) {...})
r.POST("/login", func(c *gin.Context) {...})

此外，还有一个可以匹配所有请求方法的Any方法如下：

go 复制代码 
r.Any("/test", func(c *gin.Context) {...})

为没有配置处理函数的路由添加处理程序，默认情况下它返回404代码，下面的代码为没有匹配到路由的请求都返回views/404.html页面。

go 复制代码 
r.NoRoute(func(c *gin.Context) {
        c.HTML(http.StatusNotFound, "views/404.html", nil)
    })

2、路由组

我们可以将拥有共同URL前缀的路由划分为一个路由组。习惯性一对{}包裹同组的路由，这只是为了看着清晰，用不用{}包裹功能上没什么区别。

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

    }
    shopGroup := r.Group("/shop")
    {
        shopGroup.GET("/index", func(c *gin.Context) {...})
        shopGroup.GET("/cart", func(c *gin.Context) {...})
        shopGroup.POST("/checkout", func(c *gin.Context) {...})
    }
    r.Run()
}

通常我们将路由分组用在划分业务逻辑或划分API版本时。

三、路由拆分与注册

1、基本的路由注册

下面是最基础的gin路由注册方式，适用于路由比较少的简单项目或者项目demo。

go 复制代码 
package main

import (
	"net/http"

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

func helloHandler(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"message": "Hello q1mi!",
	})
}

func main() {
	r := gin.Default()
	r.GET("/hello", helloHandler)
	if err := r.Run(); err != nil {
		fmt.Println("startup service failed, err:%v\n", err)
	}
}

2、路由拆分成单独文件或包

当项目的规模增大后就不太适合继续在项目的main.go文件中去实现路由注册相关逻辑了，我们会倾向于把路由部分的代码都拆分出来，形成一个单独的文件或包：

我们在routers.go文件中定义并注册路由信息：

go 复制代码 
package main

import (
	"net/http"

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

func helloHandler(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"message": "Hello q1mi!",
	})
}

func setupRouter() *gin.Engine {
	r := gin.Default()
	r.GET("/hello", helloHandler)
	return r
}

此时main.go中调用上面定义好的setupRouter函数：

go 复制代码 
func main() {
	r := setupRouter()
	if err := r.Run(); err != nil {
		fmt.Println("startup service failed, err:%v\n", err)
	}
}

此时的目录结构：

go 复制代码 
gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers.go

一般会把路由部分的代码单独拆分成包的，拆分后的目录结构如下：

go 复制代码 
gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers
    └── routers.go

routers/routers.go

需要注意此时setupRouter需要改成首字母大写，因为和main.go已经不在一个包中了，要在main.go中调用SetupRouter，所以他必须是可导出的：

go 复制代码 
package routers

import (
	"net/http"

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

func helloHandler(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"message": "Hello q1mi!",
	})
}

// SetupRouter 配置路由信息
func SetupRouter() *gin.Engine {
	r := gin.Default()
	r.GET("/hello", helloHandler)
	return r
}

main.go文件内容如下：

go 复制代码 
package main

import (
	"fmt"
	"gin_demo/routers"
)

func main() {
	r := routers.SetupRouter()
	if err := r.Run(); err != nil {
		fmt.Println("startup service failed, err:%v\n", err)
	}
}

3、路由拆分成多个文件

当我们的业务规模继续膨胀，单独的一个routers文件或包已经满足不了我们的需求了，

go 复制代码 
func SetupRouter() *gin.Engine {
	r := gin.Default()
	r.GET("/hello", helloHandler)
    r.GET("/xx1", xxHandler1)
    ...
    r.GET("/xx30", xxHandler30)
	return r
}

因为我们把所有的路由注册都写在一个SetupRouter函数中的话就会太复杂了。

我们可以分开定义多个路由文件，例如：

go 复制代码 
gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers
    ├── blog.go
    └── shop.go

routers/shop.go中添加一个LoadShop的函数，将shop相关的路由注册到指定的路由器：

go 复制代码 
func LoadShop(e *gin.Engine)  {
	e.GET("/hello", helloHandler)
  	e.GET("/goods", goodsHandler)
    e.GET("/checkout", checkoutHandler)
  ...
}

routers/blog.go中添加一个LoadBlog的函数，将blog相关的路由注册到指定的路由器：

go 复制代码 
func LoadBlog(e *gin.Engine) {
	e.GET("/post", postHandler)
 	e.GET("/comment", commentHandler)
  ...
}

在main函数中实现最终的注册逻辑如下：

go 复制代码 
func main() {
	r := gin.Default()
	routers.LoadBlog(r)
	routers.LoadShop(r)
	if err := r.Run(); err != nil {
		fmt.Println("startup service failed, err:%v\n", err)
	}
}

4、路由拆分到不同的APP

有时候项目规模实在太大，那么我们就更倾向于把业务拆分的更详细一些，例如把不同的业务代码拆分成不同的APP。

因此我们在项目目录下单独定义一个app目录，用来存放我们不同业务线的代码文件，这样就很容易进行横向扩展。大致目录结构如下：

go 复制代码 
gin_demo
├── app
│   ├── blog
│   │   ├── handler.go
│   │   └── router.go
│   └── shop
│       ├── handler.go
│       └── router.go
├── go.mod
├── go.sum
├── main.go
└── routers
    └── routers.go

其中app/blog/router.go用来定义post相关路由信息，具体内容如下：

go 复制代码 
func Routers(e *gin.Engine) {
	e.GET("/post", postHandler)
	e.GET("/comment", commentHandler)
}

app/shop/router.go用来定义shop相关路由信息，具体内容如下：

go 复制代码 
func Routers(e *gin.Engine) {
	e.GET("/goods", goodsHandler)
	e.GET("/checkout", checkoutHandler)
}

在第三步迭代中（3、路由拆分成多个文件），我们在main.go中使用了两次routers.LoadXXX(r)，事实上他们是同种类型的函数,当这种调用比较多时也是累赘，故可以定义option，使用函数数选项模式使得代码更优雅。

go 复制代码 
func main() {
	r := gin.Default()
	// 使用了两次routers.LoadXXX(r)
	routers.LoadBlog(r)
	routers.LoadShop(r)
	if err := r.Run(); err != nil {
		fmt.Println("startup service failed, err:%v\n", err)
	}
}

routers/routers.go中根据需要定义Include函数用来注册子app中定义的路由，Init函数用来进行路由的初始化操作：

go 复制代码 
type Option func(*gin.Engine)

var options = []Option{}

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

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

main.go中按如下方式先注册子app中的路由，然后再进行路由的初始化：

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)
	}
}
相关推荐
nbsaas-boot10 小时前
Go vs Java 的三阶段切换路线图
java·开发语言·golang
modelmd13 小时前
Go 编程语言指南 练习题目分享
开发语言·学习·golang
福大大架构师每日一题17 小时前
2026年1月TIOBE编程语言排行榜，Go语言排名第16，Rust语言排名13。C# 当选 2025 年度编程语言。
golang·rust·c#
拔剑纵狂歌19 小时前
helm-cli安装资源时序报错问题问题
后端·docker·云原生·容器·golang·kubernetes·腾讯云
bing.shao21 小时前
AI在电商上架图片领域的应用
开发语言·人工智能·golang
源代码•宸21 小时前
Leetcode—712. 两个字符串的最小ASCII删除和【中等】
开发语言·后端·算法·leetcode·职场和发展·golang·dp
源代码•宸1 天前
Golang语法进阶（Context）
开发语言·后端·算法·golang·context·withvalue·withcancel
源代码•宸1 天前
Golang语法进阶（Sync、Select）
开发语言·经验分享·后端·算法·golang·select·pool
IT=>小脑虎1 天前
Go语言零基础小白学习知识点【基础版详解】
开发语言·后端·学习·golang
源代码•宸1 天前
Golang语法进阶（并发概述、Goroutine、Channel）
服务器·开发语言·后端·算法·golang·channel·goroutine
热门推荐
01GitHub 镜像站点02Labelme从安装到标注：零基础完整指南03Linux下V2Ray安装配置指南04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05jdk21下载、安装（Windows、Linux、macOS）06KGG转MP3工具|非KGM文件|解密音频07Claude Code 2.1.2 升级报错？别折腾了，一行命令搞定08【踩坑笔记】50系显卡适配的 PyTorch 安装092025-04-03 Latex学习1——本地配置Latex + VScode环境10UV安装并设置国内源