func main() {
//创建一个无中间件路由
router := gin.New()
router.Run()
}

func main() {
// 默认启动方式，包含 Logger、Recovery 中间件
router:=gin.Default()
router.GET("/", func(context *gin.Context) {
	context.JSON(200,gin.H{
		"goods_name":"牛奶",
	})
})
router.Run()
}

结论: 上图控制台输出便是gin.Logger中间件输出访问记录到控制台

//自定义中间件第1种定义方式
func CustomRouterMiddle1(c *gin.Context)  {
	t := time.Now()
	fmt.Println("我是自定义中间件第1种定义方式---请求之前")
	//在gin上下文中定义一个变量
	c.Set("example", "CustomRouterMiddle1")
	//请求之前
	c.Next()
	fmt.Println("我是自定义中间件第1种定义方式---请求之后")
	//请求之后
	//计算整个请求过程耗时
	t2 := time.Since(t)
	log.Println(t2)

}

//自定义中间件第2种定义方式
func CustomRouterMiddle2() gin.HandlerFunc{
	return func(c *gin.Context) {
		t := time.Now()
		fmt.Println("我是自定义中间件第2种定义方式---请求之前")
		//在gin上下文中定义一个变量
		c.Set("example", "CustomRouterMiddle2")
		//请求之前
		c.Next()
		fmt.Println("我是自定义中间件第2种定义方式---请求之后")
		//请求之后
		//计算整个请求过程耗时
		t2 := time.Since(t)
		log.Println(t2)
	}
}



func main() {
	
	r := gin.New()
	
	//测试时下面两个中间件选择一个，注释一个
	r.Use(CustomRouterMiddle1)
	r.Use(CustomRouterMiddle2())

	r.GET("/test", func(c *gin.Context) {
		example := c.MustGet("example").(string)

		//
		log.Println(example)
	})

	// 监听本地8080端口
	r.Run(":8080")
}

func RouterMiddle1(c *gin.Context)  {
	fmt.Println("我是路由中间件1")
}

func RouterMiddle2(c *gin.Context)  {
	fmt.Println("我是路由中间件2")
}

func oneRouterMiddleHandle() gin.HandlerFunc{
	return func(c *gin.Context) {
		fmt.Println("我是业务处理函数")
	}
}

func main() {
	//创建一个无中间件路由
	router := gin.New()
	// 对于每个路由中间件，您可以添加任意数量的路由中间件
	router.GET("/oneRouterMiddle", RouterMiddle1,RouterMiddle2,oneRouterMiddleHandle())
	// 默认监听本地 0.0.0.0:8080 即localhost:8080 或 127.0.0.1:8080
	router.Run()
}

结论: 从上图可以看出单个路由的中间件是可以添加多个的，并按照添加的函数顺序执行的，所以我们把业务函数放在最后一个

func GroupRouterGoodsMiddle1(c *gin.Context)  {
	fmt.Println("我是goods路由组中间件1")
}

func GroupRouterGoodsMiddle2(c *gin.Context) {
	fmt.Println("我是goods路由组中间件2")
}

func GroupRouterOrderMiddle1(c *gin.Context) {
	fmt.Println("我是order路由组中间件1")
}

func GroupRouterOrderMiddle2(c *gin.Context) {
	fmt.Println("我是order路由组中间件2")
}

func main() {
	//创建一个无中间件路由
	router := gin.New()
	router.Use(gin.Logger())

	//第1种路由组使用方式 可以添加多个处理函数 但是不知道为什么 官方举例的这第一种方式用不了
	router.Group("/goods", GroupRouterGoodsMiddle1, GroupRouterGoodsMiddle2)
	router.GET("/goods/add", func(context *gin.Context) {
		fmt.Println("/goods/add")
	})


	//第2种路由组使用方式
	orderGroup := router.Group("/order")
	orderGroup.Use(GroupRouterOrderMiddle1, GroupRouterOrderMiddle2)
	{
		orderGroup.GET("/add", func(context *gin.Context) {
			fmt.Println("/order/add")

		})

		orderGroup.GET("/del", func(context *gin.Context) {
			fmt.Println("/order/del")

		})

		//orderGroup下再嵌套一个testGroup
		testGroup:=orderGroup.Group("/test", func(context *gin.Context) {
			fmt.Println("order/test下的中间件")
		})

		testGroup.GET("/test1", func(context *gin.Context) {
			fmt.Println("order/test/test1的函数")
		})
	}

	router.Run()
}

func GlobalMiddle(c *gin.Context){
	fmt.Println("我是全局中间件")
}

func main() {
//创建一个无中间件路由
router := gin.New()

//使用自定义的全局中间件
router.Use(GlobalMiddle)

router.GET("/", func(context *gin.Context) {
	fmt.Println("我是/")
})

router.Run()
}

这里我就不用代码展示了。大家在前面代码上测试下就行了，这里直接告诉大家结果。
结论： 全局中间件 > 路由组中间件 > 路由中间件
全局中间件最先执行

上图是官方示例，在第1种路由组使用方式，实际测试用不了。不知道是我太菜还是真是官方的bug，如果有小伙伴发现什么可以和我评论交流。