Using Middleware in Fiber: A Guide to Request Handling

Middleware is one of the most powerful features in web development, acting as the backbone of request processing in modern web applications. In this guide, we’ll explore how to effectively use middleware in Fiber, the Express-inspired web framework for Go that’s been gaining tremendous popularity for its speed and simplicity.

Understanding Middleware in Fiber

At its core, middleware functions in Fiber are pieces of code that have access to the request-response cycle. They can execute any code, make changes to the request and response objects, end the request-response cycle, or call the next middleware function in the stack.

Let’s start with a basic example:

app := fiber.New()

app.Use(func(c *fiber.Ctx) error {
    fmt.Println("I'm a middleware!")
    return c.Next()
})

Common Use Cases for Middleware

1. Authentication

One of the most common uses of middleware is authentication. Here’s how you might implement a simple auth middleware:

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

2. Request Logging

Monitoring requests is crucial for debugging and analytics:

func LoggerMiddleware(c *fiber.Ctx) error {
    start := time.Now()

    err := c.Next()

    log.Printf(
        "%s %s %v",
        c.Method(),
        c.Path(),
        time.Since(start),
    )
    return err
}

Advanced Middleware Patterns

Local vs Global Middleware

Fiber allows you to apply middleware globally or to specific routes:

// Global middleware
app.Use(LoggerMiddleware)

// Route-specific middleware
app.Get("/protected", AuthMiddleware, HandleProtectedRoute)

Middleware Chaining

You can chain multiple middleware functions for complex processing:

app.Use(
    Compress(),
    Cors(),
    Cache(),
    RateLimiter(),
)

Best Practices

1. Keep middleware functions focused and single-purpose
2. Order your middleware carefully - the sequence matters
3. Always call c.Next() unless you’re intentionally ending the request
4. Handle errors appropriately
5. Use middleware for cross-cutting concerns

Remember that while middleware is powerful, each additional function in the chain adds to the request processing time. Use them judiciously and monitor their performance impact.