在之前的文章介绍中我们已经完成了一个API服务的全链路请求设计。调用方式可以看Test目录的代码
// src/test/request_test.go
func TestAPI_Request(t *testing.T) {
url := "127.0.0.1:8080"
ak := "A00001"
sk := "SECRET-A00001"
api := NewAPI(url, ak, sk)
params := map[string]interface{}{
"ip": "10.1.162.18",
}
if result, err := api.Request("/", "GET", params); err != nil {
t.Fatal(err)
} else {
t.Log(result)
}
}
重复的路由现象
截至目前我们只定义了一个路由（在main函数中），但现实中往往会定义多个路由实现多个API接口，而为了风格统一化（或是模块化、版本区分等原因），我们也往往会将多个路由归为一类，这就会导致很多路由的前缀相同。
所以，本文将介绍如何通过分组路由，减少路由重复代码并实现动态路由。
- 路由定义
func main() {
...
r.GET("/", v1_sdk_search_ip.SearchIpHandlerWithGet)
...
}
- 重复路由前缀
/sdk/search_ip
/sdk/search_mac
/object/host
/object/switch
/v1/object/host
/v1/object/switch
/v2/object/host
/v2/object/switch
分组路由
通过Group方法来生成一个分组，然后使用这个分组来注册多个统一分类的路由
/*
/sdk/search_ip
/sdk/search_mac
/object/host
/object/switch
*/
route := gin.Default()
// sdk 类别
sdkGroup := route.Group("/sdk")
sdkGroup.GET("/search_mac", func(c *gin.Context) {
c.String(200, "sdk search mac")
})
sdkGroup.GET("/search_ip", func(c *gin.Context) {
c.String(200, "sdk search ip")
})
// object
objGroup := route.Group("/object")
objGroup.GET("/host", func(c *gin.Context) {
c.String(200, "get object host")
})
objGroup.POST("/switch", func(c *gin.Context) {
c.String(200, "post object switch")
})
如果需要对sdk类别的路由进行统一调用某个中间件，也可以使用Group的第二个参数。则不管是search_ip还是search_mac都会调用这个中间件
sdkGroup := route.Group("/sdk", func(c *gin.Context) {
fmt.Println("这是sdk中间件")
})
嵌套分组路由
分组路由也可以继续分组，达到嵌套分组的目的
/*
/v1/object/host
/v1/object/switch
/v2/object/host
/v2/object/switch
*/
v1Group := route.Group("/v1")
v1ObjGroup := v1Group.Group("/object")
v1ObjGroup.GET("/host", func(c *gin.Context) {
c.String(200, "get object host")
})
v1ObjGroup.POST("/switch", func(c *gin.Context) {
c.String(200, "post object switch")
})
v2Group := route.Group("/v2")
v2ObjGroup := v2Group.Group("/object")
v2ObjGroup.GET("/host", func(c *gin.Context) {
c.String(200, "get object host")
})
v2ObjGroup.POST("/switch", func(c *gin.Context) {
c.String(200, "post object switch")
})
Gin-IPs动态路由
有了上面路由分组和嵌套分组的基础后，我们就可以通过自定义函数来组装路由，实现路由的动态分发了
- 代码实现
type Route map[string]func(c *gin.Context) // key:uri路径, value: 中间件函数
type Method int
const (
GET Method = iota
POST
DELETE
PUT
)
// devPkg 对应的路由
type DevPkgGroup struct {
Name configure.DevPkg
Routes []map[Method]Route
}
// 版本对应的路由
type Group struct {
Version string
PkgList []DevPkgGroup
}
var RGroups []Group
func InitRouteGroups() {
RGroups = []Group{
{"v1", // RGroups[0] 表示 V1， RGroups[1] 表示 V2
[]DevPkgGroup{},
},
}
/*---------- 更新 V1 路由 ----------*/
// Object 路由，根据oid遍历多个
var objectRoutes []map[Method]Route
for _, oid := range configure.OidArray { // 动态添加所有的oid路由
uri, postFunc := v1_object.AllInstancesPostFunc(oid) // POST /v1/object/$oid
objectRoutes = append(objectRoutes, map[Method]Route{POST: {uri: postFunc}})
uri, getFunc := v1_object.SingleInstanceGetFunc(oid) // GET /v1/object/$oid/$id
objectRoutes = append(objectRoutes, map[Method]Route{GET: {uri: getFunc}})
}
RGroups[0].PkgList = append(RGroups[0].PkgList, DevPkgGroup{configure.ObjectPkg, objectRoutes})
// Sdk 路由
var sdkRoutes []map[Method]Route
// Sdk Get 路由
sdkGetFuncArr := []func() (string, func(c *gin.Context)){
v1_sdk.SearchIpFunc, // Get /v1/sdk/search_ip?ip='xxx'
}
for _, sdkGetFunc := range sdkGetFuncArr {
sdkGetUri, sdkGetFunc := sdkGetFunc()
sdkRoutes = append(sdkRoutes, map[Method]Route{GET: {sdkGetUri: sdkGetFunc}})
}
RGroups[0].PkgList = append(RGroups[0].PkgList, DevPkgGroup{configure.SdkPkg, sdkRoutes})
}
func methodMapper(group *gin.RouterGroup, method Method) func(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
if method == GET {
return group.GET
}
if method == POST {
return group.POST
}
if method == DELETE {
return group.DELETE
}
if method == PUT {
return group.PUT
}
return group.Any
}
// 路由解析
func AddRoute(app *gin.Engine) {
cmdbGroup := app.Group("/")
for _, group := range RGroups {
versionGroup := cmdbGroup.Group(group.Version)
for _, sdk := range group.PkgList {
sdkGroup := versionGroup.Group(string(sdk.Name))
for _, mapper := range sdk.Routes {
for method, route := range mapper {
for uri, handler := range route {
methodMapper(sdkGroup, method)(uri, handler)
}
}
}
}
}
}
- 效果展示
[GIN-debug] POST /v1/object/HOST --> Gin-IPs/src/route/v1/object.glob..func1.1 (4 handlers)
[GIN-debug] GET /v1/object/HOST/:id --> Gin-IPs/src/route/v1/object.glob..func2.1 (4 handlers)
[GIN-debug] POST /v1/object/SWITCH --> Gin-IPs/src/route/v1/object.glob..func1.1 (4 handlers)
[GIN-debug] GET /v1/object/SWITCH/:id --> Gin-IPs/src/route/v1/object.glob..func2.1 (4 handlers)
[GIN-debug] GET /v1/sdk/search_ip --> Gin-IPs/src/route/v1/sdk.glob..func1.1 (4 handlers)
实现了动态路由之后我们的路由管理变得非常简单，且很多代码可以重复利用。而且在此基础上，我们还可以通过对不同的路由进行权限控制，以实现权限的精细管理。
Github 代码
请访问 Gin-IPs 或者搜索 Gin-IPs