Middleware in Chi: How to Create and Use It

Middleware in Chi is like a series of checkpoints your HTTP requests pass through before reaching their final destination. Think of it as a bouncer at a club, checking IDs and making sure everything’s in order before letting people in. Let’s dive into how you can create and use middleware in Chi to make your Go web applications more robust and organized.

Understanding Middleware Basics

In its simplest form, middleware is just a function that processes HTTP requests before they hit your main handler. It can modify the request, perform checks, or even stop the request from proceeding further if needed.

Creating Your First Middleware

Here’s how you can create a basic logging middleware in Chi:

func LoggerMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // Call the next handler
        next.ServeHTTP(w, r)

        // Log after the request is done
        fmt.Printf("Request to %s completed in %v\n",
            r.URL.Path,
            time.Since(start))
    })
}

Using Middleware in Chi

Chi offers several ways to use middleware. You can apply it globally, to specific routes, or to groups of routes:

r := chi.NewRouter()

// Global middleware
r.Use(LoggerMiddleware)

// Route-specific middleware
r.With(AuthMiddleware).Get("/protected", protectedHandler)

// Group middleware
r.Group(func(r chi.Router) {
    r.Use(AuthMiddleware)
    r.Get("/admin", adminHandler)
    r.Get("/dashboard", dashboardHandler)
})

Best Practices

1. Keep your middleware focused on a single responsibility
2. Order matters - place your middleware in a logical sequence
3. Remember that middleware runs in the order you define it
4. Use middleware to separate cross-cutting concerns from your main logic

Here’s an example of combining multiple middleware functions:

r := chi.NewRouter()
r.Use(middleware.RequestID)
r.Use(middleware.RealIP)
r.Use(middleware.Logger)
r.Use(middleware.Recoverer)

Conclusion

Middleware in Chi provides a powerful way to modularize your application’s HTTP request processing. By understanding how to create and use middleware effectively, you can build more maintainable and feature-rich web applications in Go.