路由组织

随着项目规模增长，路由管理变得重要。良好的路由组织能让代码更易维护。

基本路由分组

package main

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

func main() {
    r := gin.Default()
    
    api := r.Group("/api")
    {
        api.GET("/health", healthCheck)
        
        v1 := api.Group("/v1")
        {
            users := v1.Group("/users")
            {
                users.GET("", listUsers)
                users.POST("", createUser)
                users.GET("/:id", getUser)
                users.PUT("/:id", updateUser)
                users.DELETE("/:id", deleteUser)
            }
            
            posts := v1.Group("/posts")
            {
                posts.GET("", listPosts)
                posts.POST("", createPost)
                posts.GET("/:id", getPost)
            }
        }
    }
    
    r.Run(":8080")
}

按模块拆分

将路由拆分到不同文件：

routes/user.go：

package routes

import "github.com/gin-gonic/gin"

func UserRoutes(r *gin.RouterGroup) {
    users := r.Group("/users")
    {
        users.GET("", listUsers)
        users.POST("", createUser)
        users.GET("/:id", getUser)
        users.PUT("/:id", updateUser)
        users.DELETE("/:id", deleteUser)
        
        users.GET("/:id/posts", getUserPosts)
        users.GET("/:id/comments", getUserComments)
    }
}

routes/post.go：

package routes

import "github.com/gin-gonic/gin"

func PostRoutes(r *gin.RouterGroup) {
    posts := r.Group("/posts")
    {
        posts.GET("", listPosts)
        posts.POST("", createPost)
        posts.GET("/:id", getPost)
        posts.PUT("/:id", updatePost)
        posts.DELETE("/:id", deletePost)
        
        posts.GET("/:id/comments", getPostComments)
        posts.POST("/:id/comments", createComment)
    }
}

main.go：

package main

import (
    "myapp/routes"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    
    api := r.Group("/api/v1")
    routes.UserRoutes(api)
    routes.PostRoutes(api)
    
    r.Run(":8080")
}

注册函数模式

type RouteRegistrar interface {
    Register(r *gin.RouterGroup)
}

type UserModule struct{}

func (m *UserModule) Register(r *gin.RouterGroup) {
    users := r.Group("/users")
    {
        users.GET("", m.listUsers)
        users.POST("", m.createUser)
        users.GET("/:id", m.getUser)
    }
}

type PostModule struct{}

func (m *PostModule) Register(r *gin.RouterGroup) {
    posts := r.Group("/posts")
    {
        posts.GET("", m.listPosts)
        posts.POST("", m.createPost)
    }
}

func main() {
    r := gin.Default()
    api := r.Group("/api/v1")
    
    modules := []RouteRegistrar{
        &UserModule{},
        &PostModule{},
    }
    
    for _, module := range modules {
        module.Register(api)
    }
    
    r.Run(":8080")
}

中间件分组

func main() {
    r := gin.Default()
    
    public := r.Group("/api")
    {
        public.POST("/login", login)
        public.POST("/register", register)
        public.GET("/health", healthCheck)
    }
    
    protected := r.Group("/api")
    protected.Use(AuthMiddleware())
    {
        protected.GET("/profile", getProfile)
        protected.PUT("/profile", updateProfile)
    }
    
    admin := r.Group("/api/admin")
    admin.Use(AuthMiddleware(), AdminMiddleware())
    {
        admin.GET("/users", listAllUsers)
        admin.DELETE("/users/:id", deleteUser)
    }
    
    r.Run(":8080")
}

路由信息导出

func main() {
    r := gin.Default()
    
    r.GET("/hello", func(c *gin.Context) { c.String(200, "hello") })
    r.POST("/user", func(c *gin.Context) { c.String(200, "user") })
    
    routes := r.Routes()
    for _, route := range routes {
        fmt.Printf("%s %s\n", route.Method, route.Path)
    }
    
    r.Run(":8080")
}

项目目录结构

推荐的项目结构：

myapp/
├── main.go
├── config/
│   └── config.go
├── routes/
│   ├── routes.go
│   ├── user.go
│   └── post.go
├── handlers/
│   ├── user.go
│   └── post.go
├── middleware/
│   ├── auth.go
│   └── logger.go
├── models/
│   ├── user.go
│   └── post.go
├── services/
│   ├── user.go
│   └── post.go
└── utils/
    └── helper.go

routes/routes.go：

package routes

import (
    "myapp/handlers"
    "myapp/middleware"
    "github.com/gin-gonic/gin"
)

func Setup(r *gin.Engine) {
    r.GET("/health", handlers.HealthCheck)
    
    api := r.Group("/api/v1")
    
    api.POST("/login", handlers.Login)
    api.POST("/register", handlers.Register)
    
    api.Use(middleware.Auth())
    {
        api.GET("/profile", handlers.GetProfile)
        api.PUT("/profile", handlers.UpdateProfile)
    }
    
    users := api.Group("/users")
    {
        users.GET("", handlers.ListUsers)
        users.GET("/:id", handlers.GetUser)
    }
    
    posts := api.Group("/posts")
    posts.Use(middleware.OptionalAuth())
    {
        posts.GET("", handlers.ListPosts)
        posts.GET("/:id", handlers.GetPost)
        posts.POST("", middleware.RequireAuth(), handlers.CreatePost)
    }
}

小结

良好的路由组织能让项目结构清晰，便于维护。按模块拆分路由文件，使用注册函数模式可以灵活组合。中间件分组可以精确控制访问权限。推荐的项目结构能让代码各司其职，易于扩展。