路由分组 #

一、路由分组概述 #

1.1 什么是路由分组 #

路由分组是将相关路由组织在一起的方式，可以共享公共的前缀、中间件等配置。

1.2 分组的优势 #

优势 说明
代码组织 按模块组织路由，结构清晰
中间件共享 分组内共享中间件
前缀管理 统一管理URL前缀
维护方便 易于修改和扩展

二、基本分组 #

2.1 创建分组 #

go 
func main() {
    app := fiber.New()
    
    // 创建API分组
    api := app.Group("/api")
    
    // 在分组下定义路由
    api.Get("/users", func(c *fiber.Ctx) error {
        return c.SendString("Users API")
    })
    
    // 完整路径: /api/users
    
    app.Listen(":3000")
}

2.2 链式分组 #

go 
func main() {
    app := fiber.New()
    
    // 链式创建分组
    app.Group("/api").
        Group("/v1").
        Get("/users", func(c *fiber.Ctx) error {
            return c.SendString("API v1 Users")
        })
    
    // 完整路径: /api/v1/users
    
    app.Listen(":3000")
}

2.3 分组变量 #

go 
func main() {
    app := fiber.New()
    
    // 保存分组引用
    api := app.Group("/api")
    v1 := api.Group("/v1")
    users := v1.Group("/users")
    
    users.Get("/", listUsers)
    users.Get("/:id", getUser)
    users.Post("/", createUser)
    
    // 完整路径:
    // GET  /api/v1/users
    // GET  /api/v1/users/:id
    // POST /api/v1/users
    
    app.Listen(":3000")
}

三、分组中间件 #

3.1 分组级别中间件 #

go 
func main() {
    app := fiber.New()
    
    // 分组中间件
    api := app.Group("/api", func(c *fiber.Ctx) error {
        c.Set("X-API-Version", "1.0")
        return c.Next()
    })
    
    api.Get("/users", func(c *fiber.Ctx) error {
        return c.SendString("Users")
    })
    
    // 所有/api下的路由都会执行中间件
    
    app.Listen(":3000")
}

3.2 多个中间件 #

go 
func main() {
    app := fiber.New()
    
    // 多个中间件
    api := app.Group("/api",
        loggerMiddleware,
        authMiddleware,
        rateLimitMiddleware,
    )
    
    api.Get("/users", getUsers)
    
    app.Listen(":3000")
}

func loggerMiddleware(c *fiber.Ctx) error {
    log.Println("Request:", c.Path())
    return c.Next()
}

func authMiddleware(c *fiber.Ctx) error {
    token := c.Get("Authorization")
    if token == "" {
        return c.Status(401).JSON(fiber.Map{
            "error": "Unauthorized",
        })
    }
    return c.Next()
}

func rateLimitMiddleware(c *fiber.Ctx) error {
    // 限流逻辑
    return c.Next()
}

3.3 Use方法添加中间件 #

go 
func main() {
    app := fiber.New()
    
    api := app.Group("/api")
    
    // 使用Use添加中间件
    api.Use(loggerMiddleware)
    api.Use(authMiddleware)
    
    api.Get("/users", getUsers)
    
    app.Listen(":3000")
}

四、嵌套分组 #

4.1 基本嵌套 #

go 
func main() {
    app := fiber.New()
    
    api := app.Group("/api")
    
    // v1版本
    v1 := api.Group("/v1")
    v1.Get("/users", getUsersV1)
    v1.Get("/posts", getPostsV1)
    
    // v2版本
    v2 := api.Group("/v2")
    v2.Get("/users", getUsersV2)
    v2.Get("/posts", getPostsV2)
    
    // 完整路径:
    // /api/v1/users
    // /api/v1/posts
    // /api/v2/users
    // /api/v2/posts
    
    app.Listen(":3000")
}

4.2 深层嵌套 #

go 
func main() {
    app := fiber.New()
    
    api := app.Group("/api")
    users := api.Group("/users")
    
    // 用户下的文章
    posts := users.Group("/:userId/posts")
    posts.Get("/", listUserPosts)
    posts.Get("/:postId", getUserPost)
    
    // 文章下的评论
    comments := posts.Group("/:postId/comments")
    comments.Get("/", listComments)
    comments.Post("/", createComment)
    
    // 完整路径:
    // GET  /api/users/:userId/posts
    // GET  /api/users/:userId/posts/:postId
    // GET  /api/users/:userId/posts/:postId/comments
    // POST /api/users/:userId/posts/:postId/comments
    
    app.Listen(":3000")
}

4.3 嵌套分组中间件 #

go 
func main() {
    app := fiber.New()
    
    api := app.Group("/api", apiLogger)
    
    // 公开API
    public := api.Group("/public")
    public.Get("/info", getPublicInfo)
    
    // 认证API
    auth := api.Group("/auth", authMiddleware)
    auth.Get("/profile", getProfile)
    auth.Get("/settings", getSettings)
    
    // 管理员API
    admin := auth.Group("/admin", adminMiddleware)
    admin.Get("/users", listAllUsers)
    admin.Delete("/users/:id", deleteUser)
    
    // 中间件执行顺序:
    // /api/public/info        → apiLogger
    // /api/auth/profile       → apiLogger → authMiddleware
    // /api/auth/admin/users   → apiLogger → authMiddleware → adminMiddleware
    
    app.Listen(":3000")
}

五、路由模块化 #

5.1 模块化设计 #

go 
// routes/api.go
package routes

import "github.com/gofiber/fiber/v2"

func SetupAPIRoutes(app *fiber.App) {
    api := app.Group("/api")
    
    SetupUserRoutes(api)
    SetupPostRoutes(api)
    SetupAuthRoutes(api)
}

// routes/user.go
package routes

import (
    "github.com/gofiber/fiber/v2"
    "myapp/handlers"
)

func SetupUserRoutes(api fiber.Router) {
    users := api.Group("/users")
    
    users.Get("/", handlers.ListUsers)
    users.Get("/:id", handlers.GetUser)
    users.Post("/", handlers.CreateUser)
    users.Put("/:id", handlers.UpdateUser)
    users.Delete("/:id", handlers.DeleteUser)
}

// routes/post.go
package routes

import (
    "github.com/gofiber/fiber/v2"
    "myapp/handlers"
)

func SetupPostRoutes(api fiber.Router) {
    posts := api.Group("/posts")
    
    posts.Get("/", handlers.ListPosts)
    posts.Get("/:id", handlers.GetPost)
    posts.Post("/", handlers.CreatePost)
    posts.Put("/:id", handlers.UpdatePost)
    posts.Delete("/:id", handlers.DeletePost)
}

// main.go
package main

import (
    "github.com/gofiber/fiber/v2"
    "myapp/routes"
)

func main() {
    app := fiber.New()
    
    routes.SetupAPIRoutes(app)
    
    app.Listen(":3000")
}

5.2 模块化注册 #

go 
// routes/router.go
package routes

import "github.com/gofiber/fiber/v2"

type RouteModule interface {
    Register(fiber.Router)
}

func RegisterModules(app *fiber.App, modules []RouteModule) {
    api := app.Group("/api")
    
    for _, module := range modules {
        module.Register(api)
    }
}

// modules/user/module.go
package user

import "github.com/gofiber/fiber/v2"

type UserModule struct{}

func (m *UserModule) Register(r fiber.Router) {
    users := r.Group("/users")
    users.Get("/", m.List)
    users.Get("/:id", m.Get)
    users.Post("/", m.Create)
}

// main.go
package main

import (
    "github.com/gofiber/fiber/v2"
    "myapp/routes"
    "myapp/modules/user"
    "myapp/modules/post"
)

func main() {
    app := fiber.New()
    
    modules := []routes.RouteModule{
        &user.UserModule{},
        &post.PostModule{},
    }
    
    routes.RegisterModules(app, modules)
    
    app.Listen(":3000")
}

六、版本化API #

6.1 URL版本化 #

go 
func main() {
    app := fiber.New()
    
    // v1版本
    v1 := app.Group("/api/v1")
    v1.Get("/users", getUsersV1)
    v1.Get("/posts", getPostsV1)
    
    // v2版本
    v2 := app.Group("/api/v2")
    v2.Get("/users", getUsersV2)
    v2.Get("/posts", getPostsV2)
    
    app.Listen(":3000")
}

6.2 Header版本化 #

go 
func main() {
    app := fiber.New()
    
    api := app.Group("/api")
    
    // 版本中间件
    api.Use(func(c *fiber.Ctx) error {
        version := c.Get("API-Version", "v1")
        c.Locals("version", version)
        return c.Next()
    })
    
    api.Get("/users", func(c *fiber.Ctx) error {
        version := c.Locals("version").(string)
        switch version {
        case "v1":
            return getUsersV1(c)
        case "v2":
            return getUsersV2(c)
        default:
            return getUsersV1(c)
        }
    })
    
    app.Listen(":3000")
}

6.3 分组版本工厂 #

go 
func main() {
    app := fiber.New()
    
    // 版本工厂
    versions := map[string]fiber.Router{
        "v1": app.Group("/api/v1"),
        "v2": app.Group("/api/v2"),
    }
    
    // 注册路由到各版本
    for _, v := range versions {
        v.Get("/users", getUsers)
        v.Get("/posts", getPosts)
    }
    
    // v1特有路由
    versions["v1"].Get("/legacy", legacyHandler)
    
    // v2特有路由
    versions["v2"].Get("/new-feature", newFeatureHandler)
    
    app.Listen(":3000")
}

七、分组配置 #

7.1 分组配置选项 #

go 
func main() {
    app := fiber.New()
    
    // 带配置的分组
    api := app.Group("/api", fiber.RouterConfig{
        // 分组特定配置
    })
    
    api.Get("/users", getUsers)
    
    app.Listen(":3000")
}

7.2 分组前缀动态化 #

go 
func main() {
    app := fiber.New()
    
    prefix := os.Getenv("API_PREFIX")
    if prefix == "" {
        prefix = "/api"
    }
    
    api := app.Group(prefix)
    api.Get("/users", getUsers)
    
    app.Listen(":3000")
}

八、实战示例 #

8.1 完整项目路由结构 #

go 
// main.go
package main

import (
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/logger"
    "github.com/gofiber/fiber/v2/middleware/recover"
    
    "myapp/routes"
)

func main() {
    app := fiber.New()
    
    // 全局中间件
    app.Use(logger.New())
    app.Use(recover.New())
    
    // 健康检查
    app.Get("/health", func(c *fiber.Ctx) error {
        return c.JSON(fiber.Map{"status": "ok"})
    })
    
    // 注册路由
    routes.Setup(app)
    
    app.Listen(":3000")
}

// routes/routes.go
package routes

import (
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/cors"
    
    "myapp/handlers"
    "myapp/middleware"
)

func Setup(app *fiber.App) {
    // 静态文件
    app.Static("/static", "./public")
    
    // API路由
    api := app.Group("/api")
    
    // CORS
    api.Use(cors.New())
    
    // 公开路由
    public := api.Group("/public")
    public.Post("/register", handlers.Register)
    public.Post("/login", handlers.Login)
    
    // 认证路由
    auth := api.Group("/auth", middleware.JWTProtected)
    auth.Get("/profile", handlers.GetProfile)
    auth.Put("/profile", handlers.UpdateProfile)
    
    // 用户路由
    users := api.Group("/users", middleware.JWTProtected)
    users.Get("/", handlers.ListUsers)
    users.Get("/:id", handlers.GetUser)
    users.Put("/:id", handlers.UpdateUser)
    
    // 管理员路由
    admin := api.Group("/admin", middleware.JWTProtected, middleware.AdminOnly)
    admin.Get("/users", handlers.AdminListUsers)
    admin.Delete("/users/:id", handlers.AdminDeleteUser)
    admin.Get("/stats", handlers.AdminStats)
}

8.2 RESTful资源路由 #

go 
// routes/resource.go
package routes

import "github.com/gofiber/fiber/v2"

type ResourceHandler interface {
    Index(c *fiber.Ctx) error
    Show(c *fiber.Ctx) error
    Store(c *fiber.Ctx) error
    Update(c *fiber.Ctx) error
    Destroy(c *fiber.Ctx) error
}

func Resource(r fiber.Router, path string, h ResourceHandler) {
    r.Get(path, h.Index)
    r.Get(path+"/:id", h.Show)
    r.Post(path, h.Store)
    r.Put(path+"/:id", h.Update)
    r.Delete(path+"/:id", h.Destroy)
}

// 使用
func main() {
    app := fiber.New()
    api := app.Group("/api")
    
    Resource(api, "/users", &UserHandler{})
    Resource(api, "/posts", &PostHandler{})
    
    app.Listen(":3000")
}

九、总结 #

9.1 核心要点 #

要点 说明
创建分组 app.Group(“/prefix”)
分组中间件 分组级别应用中间件
嵌套分组 支持多层嵌套
模块化 按模块组织路由
版本化 支持API版本管理

9.2 下一步 #

现在你已经掌握了路由分组，接下来让我们学习 HTTP方法，了解各种HTTP请求的处理！

最后更新：2026-03-28