1. 路由拆分与注册

    下面最基础的gin路由注册方式，适用于路由条目比较少的简单项目或者项目demo。

    当项目的规模增大后就不太适合继续在项目的main.go文件中去实现路由注册相关逻辑了，我们会倾向于把路由部分的代码都拆分出来，形成一个单独的文件或包：

    我们在routers.go文件中定义并注册路由信息：

    3. import (
    4.     "net/http"
    6.     "github.com/gin-gonic/gin"
    7. )
    9. func helloHandler(c *gin.Context) {
    10.     c.JSON(http.StatusOK, gin.H{
    11.         "message": "Hello www.topgoer.com!",
    12.     })
    13. }
    15. func setupRouter() *gin.Engine {
    16.     r := gin.Default()
    17.     r.GET("/topgoer", helloHandler)
    18.     return r
    19. }

    此时main.go中调用上面定义好的setupRouter函数：

    1. func main() {
    2.     r := setupRouter()
    3.     if err := r.Run(); err != nil {
    4.         fmt.Println("startup service failed, err:%v\n", err)
    5.     }
    6. }

    此时的目录结构：

    1. gin_demo
    2. ├── go.mod
    3. ├── go.sum
    4. ├── main.go
    5. └── routers.go

    把路由部分的代码单独拆分成包的话也是可以的，拆分后的目录结构如下：

    1. gin_demo
    2. ├── go.mod
    3. ├── main.go
    4. └── routers
    5.     └── routers.go

    main.go文件内容如下：

    3. import (
    4.     "fmt"
    5.     "gin_demo/routers"
    6. )
    8. func main() {
    9.     r := routers.SetupRouter()
    10.     if err := r.Run(); err != nil {
    11.         fmt.Println("startup service failed, err:%v\n", err)
    12.     }
    13. }

    当我们的业务规模继续膨胀，单独的一个routers文件或包已经满足不了我们的需求了，

    1. func SetupRouter() *gin.Engine {
    2.     r := gin.Default()
    3.     r.GET("/topgoer", helloHandler)
    4.   r.GET("/xx1", xxHandler1)
    5.   ...
    6.   r.GET("/xx30", xxHandler30)
    7.     return r
    8. }

    因为我们把所有的路由注册都写在一个SetupRouter函数中的话就会太复杂了。

    我们可以分开定义多个路由文件，例如：

    1. gin_demo
    2. ├── go.mod
    3. ├── go.sum
    4. ├── main.go
    5. └── routers
    6.     ├── blog.go
    7.     └── shop.go

    routers/shop.go中添加一个LoadShop的函数，将shop相关的路由注册到指定的路由器：

    1. func LoadShop(e *gin.Engine)  {
    2.     e.GET("/hello", helloHandler)
    3.   e.GET("/goods", goodsHandler)
    4.   e.GET("/checkout", checkoutHandler)
    5.   ...

    routers/blog.go中添加一个LoadBlog的函数，将blog相关的路由注册到指定的路由器：

    1. func main() {
    2.     r := gin.Default()
    4.     routers.LoadShop(r)
    5.     if err := r.Run(); err != nil {
    6.         fmt.Println("startup service failed, err:%v\n", err)
    7.     }
    8. }

    有时候项目规模实在太大，那么我们就更倾向于把业务拆分的更详细一些，例如把不同的业务代码拆分成不同的APP。

    因此我们在项目目录下单独定义一个app目录，用来存放我们不同业务线的代码文件，这样就很容易进行横向扩展。大致目录结构如下：

    1. gin_demo
    2. ├── app
    3. │   ├── blog
    4. │   │   ├── handler.go
    5. │   │   └── router.go
    6. │   └── shop
    7. │       ├── handler.go
    8. │       └── router.go
    9. ├── go.mod
    10. ├── go.sum
    11. ├── main.go
    12. └── routers
    13.     └── routers.go

    其中app/blog/router.go用来定义post相关路由信息，具体内容如下：

    1. func Routers(e *gin.Engine) {
    2.     e.GET("/post", postHandler)
    3.     e.GET("/comment", commentHandler)
    4. }

    app/shop/router.go用来定义shop相关路由信息，具体内容如下：

    1. func Routers(e *gin.Engine) {
    2.     e.GET("/goods", goodsHandler)
    3.     e.GET("/checkout", checkoutHandler)
    4. }

    routers/routers.go中根据需要定义Include函数用来注册子app中定义的路由，Init函数用来进行路由的初始化操作：

    main.go中按如下方式先注册子app中的路由，然后再进行路由的初始化：

    1. func main() {
    2.     // 加载多个APP的路由配置
    3.     routers.Include(shop.Routers, blog.Routers)
    4.     // 初始化路由
    5.     r := routers.Init()
    6.     if err := r.Run(); err != nil {
    7.         fmt.Println("startup service failed, err:%v\n", err)
    8. }