在我们开发定义路由的时候，可能会遇到很多部分重复的路由：

  1. /admin/users 
  2. /admin/manager 
  3. /admin/photo

以上等等，这些路由最前面的部分/admin/是相同的，如果我们一个个写也没问题，但是不免会觉得琐碎、重复，无用劳动，那么有没有一种更好的办法来解决呢？Gin为我们提供的解决方案就是分组路由

分组路由

类似以上示例，就是分好组的路由，分组的原因有很多，比如基于模块化，把同样模块的放在一起，比如基于版本，把相同版本的API放一起，便于使用。在有的框架中，分组路由也被称之为命名空间。
假如我们现在要升级新版本APi，但是旧的版本我们又要保留以兼容老用户。那么我们使用Gin就可以这么做

  1. func main() {
  2.     r := gin.Default()
  4.     //V1版本的API
  5.     v1Group := r.Group("/v1")
  6.     v1Group.GET("/users", func(c *gin.Context) {
  7.         c.String(200, "/v1/users")
  8.     })
  9.     v1Group.GET("/products", func(c *gin.Context) {
  10.         c.String(200, "/v1/products")
  11.     })
  13.     //V2版本的API
  14.     v2Group := r.Group("/v2")
  15.     v2Group.GET("/users", func(c *gin.Context) {
  16.         c.String(200, "/v2/users")
  17.     })
  18.     v2Group.GET("/products", func(c *gin.Context) {
  19.         c.String(200, "/v2/products")
  20.     })
  22.     r.Run(":8080")
  23. }

只需要通过Group方法就可以生成一个分组，然后用这个分组来注册不同路由，用法和我们直接使用r变量一样，非常简单。这里为了便于阅读，一般都是把不同分组的，用{}括起来。

  1.     v1Group := r.Group("/v1")
  2.     {
  3.         v1Group.GET("/users", func(c *gin.Context) {
  4.             c.String(200, "/v1/users")
  5.         })
  6.         v1Group.GET("/products", func(c *gin.Context) {
  7.             c.String(200, "/v1/products")
  8.         })
  9.     }
  11.     v2Group := r.Group("/v2")
  12.     {
  13.         v2Group.GET("/users", func(c *gin.Context) {
  14.             c.String(200, "/v2/users")
  15.         })
  16.         v2Group.GET("/products", func(c *gin.Context) {
  17.             c.String(200, "/v2/products")
  18.         })
  19.     }

路由中间件

通过Group方法的定义，我们可以看到，它是可以接收两个参数的：

  1. func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup

第一个就是我们注册的分组路由（命名空间）；第二个是一个…HandlerFunc，可以把它理解为这个分组路由的中间件，所以这个分组路由下的子路由在执行的时候，都会调用它。
这样就给我们带来很多的便利，比如请求的统一处理，比如/admin分组路由下的授权校验处理。比如刚刚上面的例子：

  1. v1Group := r.Group("/v1", func(c *gin.Context) {
  2.         fmt.Println("/v1中间件")
  3.     })

这样不管你是访问/v1/users，还是访问/v1/products,控制台都会打印出/v1中间件。
从Group的方法定义，还可以看到，我们可以注册多个HandlerFunc，对分组路由进行多次处理。

分组路由嵌套

我们不光可以定义一个分组路由，还可以在这个分组路由中再添加一个分组路由，达到分组路由嵌套的目的，这种业务场景也不少，比如：

  1. /v1/admin/users 
  2. /v1/admin/manager 
  3. /v1/admin/photo

V1版本下的admin模块，我们使用Gin可以这么实现。

  1. v1AdminGroup := v1Group.Group("/admin")
  2.     {
  3.         v1AdminGroup.GET("/users", func(c *gin.Context) {
  4.             c.String(200, "/v1/admin/users")
  5.         })
  6.         v1AdminGroup.GET("/manager", func(c *gin.Context) {
  7.             c.String(200, "/v1/admin/manager")
  8.         })
  9.         v1AdminGroup.GET("/photo", func(c *gin.Context) {
  10.             c.String(200, "/v1/admin/photo")
  11.         })
  12.     }

如上代码，再调用一次Group生成一个分组路由即可，就是这么简单，通过这种方式你还可以继续嵌套。

原理解析

那么以前这种分组路由这么方便，实现会不会很复杂呢？我们来看看源代码，分析一下它的实现方式。
在分析之前，我们先来看看我们最开始用的GET方法签名。

  1. func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
  2.     return group.handle("GET", relativePath, handlers)
  3. }

注意第一个参数relativePath，这是一个相对路径，也就是我们传给Gin的是一个相对路径，那么是相对谁的呢？

  1. func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
  2.     absolutePath := group.calculateAbsolutePath(relativePath)
  3.     handlers = group.combineHandlers(handlers)
  4.     group.engine.addRoute(httpMethod, absolutePath, handlers)
  5.     return group.returnObj()
  6. }

通过这句absolutePath := group.calculateAbsolutePath(relativePath)代码，我们可以看出是相对当前的这个group(方法接收者)的。
现在calculateAbsolutePath方法的源代码我们暂时不看，回过头来看Group这个生成分组路由的方法。

  1. func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
  2.     return &RouterGroup{
  3.         Handlers: group.combineHandlers(handlers),
  4.         basePath: group.calculateAbsolutePath(relativePath),
  5.         engine:   group.engine,
  6.     }
  7. }

这里要注意的是,我们通过gin.Default()生成的gin.Engine其实包含一个RouterGroup(嵌套组合),所以它可以用RouterGroup的方法。
Group方法又生成了一个*RouterGroup，这里最重要的就是basePath,它的值是group.calculateAbsolutePath(relativePath)，和我们刚刚暂停的分析的方法一样，既然这样，就来看看这个方法吧。

  1. func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {
  2.     return joinPaths(group.basePath, relativePath)
  3. }

就是一个基于当前RouterGroup的basePath的路径拼接，所以我们通过Group方法改变新生成RouterGroup中的basePath，就达到了路由分组的目的。
同时因为多次调用Group方法，都是基于上一个RouterGroup的basePath拼接成下一个RouterGroup的basePath，也就达到了路由分组嵌套的目的。
而我们通过gin.Default()生成的最初的gin.Engine ，对应的basePath是/，根节点。
这是一种非常棒的代码实现方式，简单的代码，是强大的功能。

小结

分组路由的功能非常强大， 可以帮助我们进行版本的升级，模块的切分，而且它的代码实现又非常简单，这就是优秀的代码。通过分析，我们可以学到很多，也能提升很多，让自己的能力不知不觉的超越同行，同事。

原文地址：
https://www.flysnow.org/2019/12/25/golang-gin-group-router.html