前言

感谢开源项目gin-vue-admin，以及1010工作室的教程，项目文档
我只是在跟着学习，然后记录下笔记而已，可能会有新的代码加入，但是本质还是跟着学习的一个过程。

什么是路由分组

对router创建Group就是分组，对同一分组会拥有统一前缀和统一中间件。
诚然这对于项目的规范管理是非常重要的

写法：router:=gin.Default()

v1 := router.Group("/v1")
v1.POST("/login", loginEndpoint)
v1.POST("/submit", submitEndpoint)
v1.POST("/read", readEndpoint)

这里的v1可以不带下划线，也是被允许的
在main.go中搭建以下代码

package main

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

func main() {
    
	r := gin.Default() //启动gin路由，携带基础中间件启动 logger and recovery (crash-free) 中间件
	v1 := r.Group("v1")
	v1.GET("test", func(c *gin.Context){
    
		fmt.Println("我在分组方法内部")
	})
	r.Run(":1010") // listen and serve on 0.0.0.0:8080
}

在postman中组件请求，直接带着分组v1进行请求。


修改代码如下，增加返回

func main() {
    
	r := gin.Default() //启动gin路由，携带基础中间件启动 logger and recovery (crash-free) 中间件
	v1 := r.Group("v1")
	v1.GET("test", func(c *gin.Context){
    
		fmt.Println("我在分组方法内部")
		c.JSON(200, gin.H{
    
			"success":true,
		})
	})
	r.Run(":1010") // listen and serve on 0.0.0.0:8080
}

postman再次发起请求


值得注意的是，这里虽然只是在创建路由分组上实现了一个请求，但是实际上可以继续创建其他请求，例如这里使用是的test，完全可以有其他的test1、test2、test3等等，但是共同的特征是他们都有一个共有前缀v1

为什么分组

• 分组可以使路由结构更加清晰
• 更加方便路由的管理

什么是中间件&使用

在请求到达路由的方法的前和后进行的一系列操作
在GIN为我们提供的基础路由中，实际上内部已经配置了两个基础中间件，看下GIN.Default的源码

// Default returns an Engine instance with the Logger and Recovery middleware already attached.
func Default() *Engine {
    
	debugPrintWARNINGDefault()
	engine := New()
	engine.Use(Logger(), Recovery())
	return engine
}

这里是使用好了Logger()中间件和Recovery()中间件。
通过Use()进行加载中间件，如果我们写中间件，使用加载时也是同样的使用这种方式

创建中间件

func middel()gin.HandlerFunc{
    
	return func(c *gin.Context) {
    
		fmt.Println("我在方法前")
		c.Next()
		fmt.Println("我在方法后")
	}
}

在v1分组上挂载中间件

func main() {
    
	r := gin.Default() //启动gin路由，携带基础中间件启动 logger and recovery (crash-free) 中间件
	v1 := r.Group("v1").Use(middel())
	v1.GET("test", func(c *gin.Context){
    
		fmt.Println("我在分组方法内部")
		c.JSON(200, gin.H{
    
			"success":true,
		})
	})
	r.Run(":1010") // listen and serve on 0.0.0.0:8080
}

如果多个中间件时，可以Use(middel1(), middel2())，也可以Use(middel1()).Use(middel2())。
通过上面的方式就使得v1挂载上中间件，也可以说是v1拥有了中间件。

postman组织请求


通过查看打印不难发现，中间件中，c.Next()前是在进入处理请求方法内部前，而c.Next()后则是在处理完请求方法后，通过中间件的方式我们就可以实现在处理请求前后实现不同的功能
当存在多个中间件时，类似于洋葱的结构

即先执行第一个中间件middel1前，执行middel2前，执行请求方法，执行middel2后，执行middel1后，类似于一个洋葱插进去。

再增加一个中间件，看下示例：

func middel()gin.HandlerFunc{
    
	return func(c *gin.Context) {
    
		fmt.Println("我在方法1前")
		c.Next()
		fmt.Println("我在方法1后")
	}
}
func middeltwo()gin.HandlerFunc{
    
	return func(c *gin.Context) {
    
		fmt.Println("我在方法2前")
		c.Next()
		fmt.Println("我在方法2后")
	}
}

func main() {
    
	r := gin.Default() //启动gin路由，携带基础中间件启动 logger and recovery (crash-free) 中间件
	v1 := r.Group("v1").Use(middel(), middeltwo())
	v1.GET("test", func(c *gin.Context){
    
		fmt.Println("我在分组方法内部")
		c.JSON(200, gin.H{
    
			"success":true,
		})
	})
	r.Run(":1010") // listen and serve on 0.0.0.0:8080
}

组织postman请求

这就清晰的展示了多个中间件是怎么使用，并且内部是如何运行的