0
0

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

文章目录

一、中间件

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

package main

import("fmt""net/http""time""github.com/gin-gonic/gin")functimeMiddleware() gin.HandlerFunc {returnfunc(ctx *gin.Context){
        begin := time.Now()deferfunc(){
            fmt.Printf("use time %d ms\n", time.Since(begin).Milliseconds())}()
        ctx.Next()}}var limitChan =make(chanstruct{},10)// 限流最高并发为10funclimitMiddleware() gin.HandlerFunc {returnfunc(ctx *gin.Context){deferfunc(){<-limitChan
        }()
        limitChan <-struct{}{}
        
        ctx.Next()}}funcbizHandler(ctx *gin.Context){
    time.Sleep(100* time.Millisecond)
    ctx.String(http.StatusOK,"gin 中间件")}funcmain(){
    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、普通路由

r.GET("/index",func(c *gin.Context){...})
r.GET("/login",func(c *gin.Context){...})
r.POST("/login",func(c *gin.Context){...})

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

Any

方法如下：

r.Any("/test",func(c *gin.Context){...})

为没有配置处理函数的路由添加处理程序，默认情况下它返回

404

代码，下面的代码为没有匹配到路由的请求都返回

views/404.html

页面。

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

2、路由组

我们可以将拥有共同

URL前缀

的路由划分为一个路由组。习惯性一对

{}

包裹同组的路由，这只是为了看着清晰，用不用

{}

包裹功能上没什么区别。

funcmain(){
    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

。

package main

import("net/http""github.com/gin-gonic/gin")funchelloHandler(c *gin.Context){
    c.JSON(http.StatusOK, gin.H{"message":"Hello q1mi!",})}funcmain(){
    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

文件中定义并注册路由信息：

package main

import("net/http""github.com/gin-gonic/gin")funchelloHandler(c *gin.Context){
    c.JSON(http.StatusOK, gin.H{"message":"Hello q1mi!",})}funcsetupRouter()*gin.Engine {
    r := gin.Default()
    r.GET("/hello", helloHandler)return r
}

此时

main.go

中调用上面定义好的

setupRouter

函数：

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

此时的目录结构：

gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers.go

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

gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers
    └── routers.go

routers/routers.go

需要注意此时

setupRouter

需要改成首字母大写，因为和

main.go

已经不在一个包中了，要在

main.go

中调用

SetupRouter

，所以他必须是可导出的：

package routers

import("net/http""github.com/gin-gonic/gin")funchelloHandler(c *gin.Context){
    c.JSON(http.StatusOK, gin.H{"message":"Hello q1mi!",})}// SetupRouter 配置路由信息funcSetupRouter()*gin.Engine {
    r := gin.Default()
    r.GET("/hello", helloHandler)return r
}

main.go

文件内容如下：

package main

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

3、路由拆分成多个文件

当我们的业务规模继续膨胀，单独的一个

routers

文件或包已经满足不了我们的需求了，

funcSetupRouter()*gin.Engine {
    r := gin.Default()
    r.GET("/hello", helloHandler)
    r.GET("/xx1", xxHandler1)...
    r.GET("/xx30", xxHandler30)return r
}

因为我们把所有的路由注册都写在一个

SetupRouter

函数中的话就会太复杂了。

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

gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers
    ├── blog.go
    └── shop.go

routers/shop.go

中添加一个

LoadShop

的函数，将

shop

相关的路由注册到指定的路由器：

funcLoadShop(e *gin.Engine){
    e.GET("/hello", helloHandler)
      e.GET("/goods", goodsHandler)
    e.GET("/checkout", checkoutHandler)...}

routers/blog.go

中添加一个

LoadBlog

的函数，将

blog

相关的路由注册到指定的路由器：

funcLoadBlog(e *gin.Engine){
    e.GET("/post", postHandler)
     e.GET("/comment", commentHandler)...}

在

main

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

funcmain(){
    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

目录，用来存放我们不同业务线的代码文件，这样就很容易进行横向扩展。大致目录结构如下：

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

相关路由信息，具体内容如下：

funcRouters(e *gin.Engine){
    e.GET("/post", postHandler)
    e.GET("/comment", commentHandler)}

app/shop/router.go

用来定义

shop

相关路由信息，具体内容如下：

funcRouters(e *gin.Engine){
    e.GET("/goods", goodsHandler)
    e.GET("/checkout", checkoutHandler)}

在第三步迭代中（3、路由拆分成多个文件），我们在

main.go

中使用了两次

routers.LoadXXX(r)

，事实上他们是同种类型的函数,当这种调用比较多时也是累赘，故可以定义

option

，使用函数数选项模式使得代码更优雅。

funcmain(){
    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

函数用来进行路由的初始化操作：

type Option func(*gin.Engine)var options =[]Option{}// 注册app的路由配置funcInclude(opts ...Option){
    options =append(options, opts...)}// 初始化funcInit()*gin.Engine {
    r := gin.New()for_, opt :=range options {opt(r)}return r
}

main.go

中按如下方式先注册

子app

中的路由，然后再进行路由的初始化：

funcmain(){// 加载多个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)}}
标签： golang gin
本文转载自: https://blog.csdn.net/YouMing_Li/article/details/136505689
版权归原作者 百里守约学编程 所有， 如有侵权，请联系我们删除。
登录后发布评论

“2. gin中间件注意事项、路由拆分与注册技巧”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航