当前位置：移动技术网 > IT编程>脚本编程>Go语言 > gin系列-中间件

gin系列-中间件

2020年04月22日 | 移动技术网IT编程 | 我要评论

gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（hook）函数。这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等

定义中间件

gin中的中间件必须是一个gin.handlerfunc类型

入门案例

package main

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

func indexhandler(c *gin.context) {
	fmt.println("index in ...")
	c.json(http.statusok, gin.h{
		"msg": "indx",
	})
}

//定义一个中间件
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
}

func main() {
	r := gin.default()
	//get(relativepath string, handlers ...handlerfunc) iroutes
	r.get("/index",m1,indexhandler)
	//r.get("/index", func(c *gin.context) {
	//	c.json(http.statusok, gin.h{
	//		"msg": "indx",
	//	})
	//})
	r.run(":9090")
}

[gin-debug] listening and serving http on :9090
m1 in ....
index in ...
[gin] 2020/04/21 - 15:21:31 |?[97;42m 200 ?[0m|       998.3µs |       127.0.0.1 |?[97;44m get     ?[0m "/index"

package main

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

func indexhandler(c *gin.context) {
	fmt.println("index in ...")
	c.json(http.statusok, gin.h{
		"msg": "indx",
	})
}

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	//输出
	// m1 in ....
	//index in ...
	//cost:%v
	// 996.8µs
}

func main() {
	r := gin.default()
	//get(relativepath string, handlers ...handlerfunc) iroutes
	r.get("/index",m1,indexhandler)  //先执行m1函数再执行indexhandler函数
	//r.get("/index", func(c *gin.context) {
	//	c.json(http.statusok, gin.h{
	//		"msg": "indx",
	//	})
	//})
	r.run(":9090")
}

注册中间件

在gin框架中，可以为每个路由添加任意数量的中间件。

为全局路由注册

package main

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

func indexhandler(c *gin.context) {
	fmt.println("index in ...")
	c.json(http.statusok, gin.h{
		"msg": "indx",
	})
}

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	fmt.println("m1 out")
	//输出
	// [gin-debug] listening and serving http on :9090
	//m1 in ....
	//m2 in ....
	//index in ...
	//m2 out
	//cost:%v
	// 997.3µs
	//m1 out
}


func m2(c *gin.context)  {
	fmt.println("m2 in ....")
	c.next() //调用后续的处理函数
	fmt.println("m2 out")
}

func main() {
	r := gin.default()
	r.use(m1,m2) //全局注册中间件函数m1,m2    洋葱模型   类似递归调用
	//get(relativepath string, handlers ...handlerfunc) iroutes
	//r.get("/index",m1,indexhandler)  //先执行m1函数再执行indexhandler函数
	r.get("/index",indexhandler)
	r.get("/shop", func(c *gin.context) {
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	r.get("/user", func(c *gin.context) {
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	r.run(":9090")
}

package main

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

func indexhandler(c *gin.context) {
	fmt.println("index in ...")
	c.json(http.statusok, gin.h{
		"msg": "indx",
	})
}

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	fmt.println("m1 out")
	//输出
	// [gin-debug] listening and serving http on :9090
	//m1 in ....
	//m2 in ....
	//m2 out
	//cost:%v
	// 997.8µs
	//m1 out
}


func m2(c *gin.context)  {
	fmt.println("m2 in ....")
	//c.next() //调用后续的处理函数
	c.abort() //阻止后续调用
	//return   //return 立即结束m2函数 
	//m1 in ....
	//m2 in ....
	//cost:%v
	// 0s
	//m1 out

	fmt.println("m2 out")
}

//func authmiddleware(c *gin.context)  {   //通常写成闭包
//	//是否登陆的判断
//	//if 是登陆用户
//	//c.next()
//	//else
//	//c.abort()
//}

func authmiddleware(docheck bool)gin.handlerfunc {   //开关注册
	//连接数据库
	//或着其他准备工作
	return func(c *gin.context) {
		if docheck {
			//是否登陆的判断
			//if 是登陆用户
			//c.next()
			//else
			//c.abort()
		} else {
			c.next()
		}
	}
	
}

func main() {
	r := gin.default()
	r.use(m1,m2,authmiddleware(true)) //全局注册中间件函数m1,m2    洋葱模型   类似递归调用
	//get(relativepath string, handlers ...handlerfunc) iroutes
	//r.get("/index",m1,indexhandler)  //先执行m1函数再执行indexhandler函数
	r.get("/index",indexhandler)
	r.get("/shop", func(c *gin.context) {
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	r.get("/user", func(c *gin.context) {
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	r.run(":9090")
}

为某个路由单独注册

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

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	fmt.println("m1 out")
}

func main() {
	r := gin.default()
	r.get("/user", m1, func(c *gin.context) {
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	//m1 in ....
	//cost:%v
	// 0s
	//m1 out
	r.run(":9090")
}

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

func indexhandler(c *gin.context) {
	fmt.println("index in ...")
	c.json(http.statusok, gin.h{
		"msg": "indx",
	})
}

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	fmt.println("m1 out")
}


func m2(c *gin.context)  {
	fmt.println("m2 in ....")
	//c.next() //调用后续的处理函数
	c.abort() //阻止后续调用
	//return   //return 立即结束m2函数
	//m1 in ....
	//m2 in ....
	//cost:%v
	// 0s
	//m1 out

	fmt.println("m2 out")
}

func main() {
	r := gin.default()
	r.get("/user", m1,m2, func(c *gin.context) {  //可以单独多个路由
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	//[gin-debug] listening and serving http on :9090
	//m1 in ....
	//m2 in ....
	//m2 out
	//cost:%v
	// 0s
	//m1 out
	r.run(":9090")
}

为路由组注册中间件

func main() {
	//路由组注册中间件方法1：
	xxgroup := r.group("/xx", authmiddleware(true))
	{
		xxgroup.get("/index", func(c *gin.context) {
			c.json(http.statusok, gin.h{"msg":"xxgroup"})
		})
	}
	//路由组注册中间件方法2：
	xx2group := r.group("/xx")
	xx2group.use(authmiddleware(true))
	{
		xxgroup.get("/index", func(c *gin.context) {
			c.json(http.statusok, gin.h{"msg":"xxgroup"})
		})
	}
	r.run(":9090")
}

跨中间件存取值

package main

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

func indexhandler(c *gin.context) {
	fmt.println("index in ...")
	name, ok := c.get("name")   //从上下文中取值，跨中间件存取值
	if !ok {
		name = "匿名用户"
	}
	c.json(http.statusok, gin.h{
		"msg": name,
	})
}

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	fmt.println("m1 out")
}


func m2(c *gin.context)  {
	fmt.println("m2 in ....")
	c.set("name","zisefeizhu")  //在上下文中设置c的值
	fmt.println("m2 out")
}

func authmiddleware(docheck bool)gin.handlerfunc {   //开关注册
	//连接数据库
	//或着其他准备工作
	return func(c *gin.context) {
		if docheck {
			//是否登陆的判断
			//if 是登陆用户
			c.next()
			//else
			//c.abort()
		} else {
			c.next()
		}
	}

}

func main() {
	r := gin.default()
	r.use(m1,m2,authmiddleware(true)) //全局注册中间件函数m1,m2    洋葱模型   类似递归调用
	//get(relativepath string, handlers ...handlerfunc) iroutes
	//r.get("/index",m1,indexhandler)  //先执行m1函数再执行indexhandler函数
	r.get("/index",indexhandler)
	r.run(":9090")
}

中间件注意事项

gin.default()

gin.default()默认使用了logger和recovery中间件，其中：logger中间件将日志写入gin.defaultwriter，即使配置了gin_mode=release。recovery中间件会recover任何panic。如果有panic的话，会写入500响应码。如果不想使用上面两个默认的中间件，可以使用gin.new()新建一个没有任何默认中间件的路由。

package main

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

func indexhandler(c *gin.context) {
	fmt.println("index in ...")
	name, ok := c.get("name")   //从上下文中取值，跨中间件存取值
	if !ok {
		name = "匿名用户"
	}
	c.json(http.statusok, gin.h{
		"msg": name,
	})
}

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	fmt.println("m1 out")
}


func m2(c *gin.context)  {
	fmt.println("m2 in ....")
	c.set("name","zisefeizhu")  //在上下文中设置c的值
	fmt.println("m2 out")
}

func authmiddleware(docheck bool)gin.handlerfunc {   //开关注册
	//连接数据库
	//或着其他准备工作
	return func(c *gin.context) {
		if docheck {
			//是否登陆的判断
			//if 是登陆用户
			c.next()
			//else
			//c.abort()
		} else {
			c.next()
		}
	}

}

func main() {
	//r := gin.default()  //默认使用logger()和recovery()中间件
	r := gin.new()
	r.use(m1,m2,authmiddleware(true)) //全局注册中间件函数m1,m2    洋葱模型   类似递归调用
	r.get("/index",indexhandler)
	r.get("/shop", func(c *gin.context) {
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	r.get("/user", func(c *gin.context) {
		c.json(http.statusok, gin.h{
			"msg": "index",
		})
	})
	r.run(":9090")
}

[gin-debug] listening and serving http on :9090
m1 in ....
m2 in ....
m2 out
index in ...
cost:%v
 1.0137ms
m1 out

gin中间件中使用goroutine

当在中间件或handler中启动新的goroutine时，不能使用原始的上下文（c *gin.context），必须使用其只读副本（c.copy()）。

//定义一个中间件:统计耗时
func m1(c *gin.context)  {
	fmt.println("m1 in ....")
	//计时
	start := time.now()
	go funcxx(c.copy()) //在funcxx中只能使用c的拷贝
	c.next() //调用后续的处理函数 执行indexhandler函数
	//c.abort() //阻止调用后续的处理函数
	cost := time.since(start)
	fmt.println("cost:%v\n", cost)
	fmt.println("m1 out")
}

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

如何用golang运行第一个项目

安装一些必要的环境1.下载go sdk (本人装的是1.9) 2.下载golang3.下载git 因为有些依赖要用 go get 去github上获取 4.配... [阅读全文]
Go打包二进制文件的实现

背景众所周知，go语言可打包成目标平台二进制文件是其一大优势，如此go项目在服务器不需要配置go环境和依赖就可跑起来。操作需求：打包部署到centos7笔者打包... [阅读全文]
golang包快速生成base64验证码的方法

base64captcha快速生成base64编码图片验证码字符串支持多种样式,算术,数字,字母,混合模式,语音模式.base64是网络上最常见的用于传输8bi... [阅读全文]
使用Go语言创建WebSocket服务的实现示例

今天介绍如何用 go 语言创建 websocket 服务，文章的前两部分简要介绍了 websocket 协议以及用 go 标准库如何创建 websocket 服... [阅读全文]
Golang通过小程序获取微信openid的方法示例

为什么要获取小程序的 openid在开发微信小程序的过程中，小程序可以通过微信官方提供的登录能力方便地获取微信提供的用户身份标识，快速建立小程序内的用户体系。那... [阅读全文]
golang语言编码规范的实现

本规范旨在为日常go项目开发提供一个代码的规范指导，方便团队形成一个统一的代码风格，提高代码的可读性，规范性和统一性。本规范将从命名规范，注释规范，代码风格和 ... [阅读全文]
Windows下安装VScode 并使用及中文配置方法

首先明确一点，vscode是开发go应用的基础编辑器，是microsoft（微软的产品），可以运行在windows、linux、mac os x上使用，默认提供... [阅读全文]
GoLang之使用Context控制请求超时的实现

起因之前接触了一个需求：提供一个接口，这个接口有一个超时时间，如果超时了返回超时异常；这个接口中调用其他的接口，如果调用超时了，所有... [阅读全文]
Golang HTTP 服务平滑重启及升级的思路

golang http服务在上线时，需要重新编译可执行文件，关闭正在运行的进程，然后再启动新的运行进程。对于访问频率比较高的面向终端用户的产品，关闭、重启的过程... [阅读全文]
VSCode1.4 搭建Golang的开发调试环境(遇到很多问题)

浪费我一天时间！唉唉唉唉唉~下载包的位置： 386 指32位系统 amd64 指64位系统还没有发现有什么区别！1、 liteide2、subli... [阅读全文]