Gin路由中间件详解

什么是中间件

中间件操作演示

方法一：

直接写在func，回调函数内

	r.GET("/middle",func(ctx *gin.Context) {
		fmt.Print("我是中间件--------")
	},func(ctx *gin.Context) {
		ctx.String(http.StatusOK,"中间件测试")
	})

方法二：

在外部构造方法

package main
 
import (
	"fmt"
	"gindemo/route"
	"net/http"
 
	"github.com/gin-gonic/gin"
)
 
//中间件测试二，在外写方法
func testMiddle (ctx *gin.Context){
	fmt.Println("卫宫士郎")
}
 
func main() {
	// 创建一个默认的路由引擎
	r := gin.Default()
 
//中间件测试二,回调函数在外面写
	r.GET("/test",testMiddle,func(ctx *gin.Context) {
		ctx.String(http.StatusOK,"方法写在外面的中间件测试")
	})
	r.Run(":8210")
}
 
 
 

ctx.Next()调用该请求的剩余处理程序 

package main
 
import (
	"fmt"
	"gindemo/route"
	"net/http"
 
	"github.com/gin-gonic/gin"
)
 
func nextMiddle (ctx *gin.Context){
	fmt.Println("next调用执行前")
	ctx.Next()
	fmt.Println("next调用执行后---")
}
 
func main() {
	// 创建一个默认的路由引擎
	r := gin.Default()
 
	//ctx.Next调用该请求的剩余处理程序
	r.GET("/next",nextMiddle,func(ctx *gin.Context) {
		fmt.Println("路由内的内容")
	},func(ctx *gin.Context) {
		ctx.String(http.StatusOK,"next调用")
	})
	r.Run(":8210")
}
 
 
 

func nextMiddle (ctx *gin.Context){
	begin := time.Now().UnixNano()
	fmt.Println("next调用执行前")
	ctx.Next()
	fmt.Println("next调用执行后---")
 
	end := time.Now().UnixNano()
	fmt.Println("执行时间为：",end-begin)
}

只需修改方法即可，然后进行访问

看回显结果

 那么有个问题，如果配置多个中间件，加上next，它的执行顺序是什么样的

一个路由配置多个中间件的执行顺序

package main
 
import (
	"fmt"
	"gindemo/route"
	"net/http"
 
	"github.com/gin-gonic/gin"
)
func nextMiddle (ctx *gin.Context){
	fmt.Println("next调用执行前---nextmiddle--1")
	ctx.Next()
	fmt.Println("next调用执行后---nextmiddle--1")
}
 
func nextMiddle2 (ctx *gin.Context){
	fmt.Println("next调用执行前---nextmiddle--2")
	ctx.Next()
	fmt.Println("next调用执行后---nextmiddle--2")
}
func main() {
	// 创建一个默认的路由引擎
	r := gin.Default()
 
	//ctx.Next调用该请求的剩余处理程序
	r.GET("/next",nextMiddle，nextMiddle2,func(ctx *gin.Context) {
		fmt.Println("路由内的内容")
	},func(ctx *gin.Context) {
		ctx.String(http.StatusOK,"next调用")
	})
	r.Run(":8210")
}
 
 
 

先头部（next前的两个下来） ，再逆序回去

思考一个问题，如果路由配置许多的话，我们需要去每个都配置中间件的话，有没有一个方法可以一键配置

全局中间件

路由.use()

package main
 
import (
	"fmt"
	"gindemo/route"
	"net/http"
 
	"github.com/gin-gonic/gin"
)
func nextMiddle (ctx *gin.Context){
	fmt.Println("next调用执行前---nextmiddle--1")
	ctx.Next()
	fmt.Println("next调用执行后---nextmiddle--1")
}
 
func nextMiddle2 (ctx *gin.Context){
	fmt.Println("next调用执行前---nextmiddle--2")
	ctx.Next()
	fmt.Println("next调用执行后---nextmiddle--2")
}
func main() {
	// 创建一个默认的路由引擎
	r := gin.Default()
    r.Use(nextMiddle,nextMiddle2)
 
	r.GET("/test",func(ctx *gin.Context) {
		ctx.String(http.StatusOK,"方法写在外面的中间件测试")
	})
 
	//ctx.Next调用该请求的剩余处理程序
	r.GET("/next",func(ctx *gin.Context) {
		fmt.Println("路由内的内容")
	},func(ctx *gin.Context) {
		ctx.String(http.StatusOK,"next调用")
	})
	r.Run(":8210")
}
 
 
 

在路由分组中配置中间件 

其一

其二 

我们依旧选择，在外部去写中间件

外部写中间件

创捷middle文件夹下，创建testmiddle,go文件

使用apiRoute进行测试

 测试

 其他的类似backRoute....未配置的是不能受到中间件的反馈的

那有没有一种方法可以使得中间件和对应控制器之间共享数据？

中间件和对应控制器之间共享数据

在外部中间件内设置值

在控制器内获取值

注意这里获取的值是空接口类型，如果要显示的话可以使用类型断言

package apifunc
 
import (
	"fmt"
	"net/http"
 
	"github.com/gin-gonic/gin"
)
 
//结构体的好处：可以让下面的方法可以访问结构体（父结构体内的方法）
type ApiInfo struct{
	Jicheng
}
 
func (way ApiInfo) Mes(ctx *gin.Context) {
	ctx.String(http.StatusOK, "Api数据回显--抽离方法---结构体！！！");
	way.Success(ctx);
	way.Fatel(ctx);
 
}
 
func (way ApiInfo)  Control(ctx *gin.Context) {
	// ctx.String(http.StatusOK, "Api数据控制--抽离方法---结构体")
	//获取值
	username,_ := ctx.Get("username")
	fmt.Println(username)
	//类型断言
	v,ok := username.(string)
	if ok == true{
		ctx.String(http.StatusOK, "Api数据控制--抽离方法---结构体---"+v)
	}else{
		ctx.String(http.StatusOK, "Api数据控制--抽离方法---结构体")
	}
 
}

 测试

注意事项:

gin 默认中间件

路由配置：

main.go :

package main
 
import (
	"fmt"
	"gindemo/route"
 
 
 
	"github.com/gin-gonic/gin"
)
 
//中间件测试二，在外写方法
func testMiddle (ctx *gin.Context){
	fmt.Println("卫宫士郎")
}
 
func nextMiddle (ctx *gin.Context){
	fmt.Println("next调用执行前---nextmiddle--1")
	ctx.Next()
	fmt.Println("next调用执行后---nextmiddle--1")
}
 
func nextMiddle2 (ctx *gin.Context){
	fmt.Println("next调用执行前---nextmiddle--2")
	ctx.Next()
	fmt.Println("next调用执行后---nextmiddle--2")
}
 
func main() {
	// 创建一个默认的路由引擎
	r := gin.Default()
 
	//加载模板 放在配置路由前面
	r.LoadHTMLGlob("templates/**/*")
	//配置静态web目录   第一个参数表示路由, 第二个参数表示映射的目录
	r.Static("/static", "./static")
 
	// 前置页面展示
	route.DefaultRoute(r)
	//接入接口展示模拟
	route.ApiRoute(r)
	//后台页面展示
	route.BackRoute(r)
 
 
 
 
	r.Run(":8210")
}