Gorilla Mux is a popular request router and dispatcher for the Go programming language. It allows developers to define routes for their web applications, and Gorilla Mux middleware functions attach to those routes to perform additional processing on incoming requests.

Routes in Gorilla Mux are defined using the mux.NewRouter() function, which returns a new instance of the mux.Router struct. Developers can then use the router’s HandleFunc() method to register a handler function for a specific HTTP method and URL path.

For example, the following code defines a route for handling GET requests to the “/users” path:
func getUsers(w http.ResponseWriter, r *http.Request) {
    // handle GET request to /users
}

router := mux.NewRouter()
router.HandleFunc("/users", getUsers).Methods("GET")

Middleware functions can be attached to routes using the Use() method of the mux.Router struct. Middleware functions are functions that take an http.Handler object as an argument and return a new http.Handler object that wraps the original handler. This allows middleware functions to modify the incoming request or response before or after the original handler is called.

For instance, the following code attaches a middleware function to the “/users” route:
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

router := mux.NewRouter()
router.Use(loggingMiddleware)
router.HandleFunc("/users", getUsers).Methods("GET")

In this case, the loggingMiddleware function logs the HTTP method and URL path of incoming requests. The next.ServeHTTP() method is called to pass the request along to the next middleware function or the final handler function.

By chaining middleware functions together, developers can create complex request processing pipelines that perform various tasks, such as authentication, logging, error handling, and more.

Given below are a few more examples of using middleware and routing in Gorilla Mux:

gorilla/mux as Authentication Middleware in Go

One common use case for middleware is authentication. Developers can create a middleware function that checks if the user is authenticated before allowing them to access certain routes. Here’s an instance:
func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Check if user is authenticated
        if !userIsAuthenticated(r) {
            http.Redirect(w, r, "/login", http.StatusSeeOther)
            return
        }
        // Call the next middleware function or final handler
        next.ServeHTTP(w, r)
    })
}

router := mux.NewRouter()
router.Use(authMiddleware)
router.HandleFunc("/dashboard", showDashboard).Methods("GET")

In this example, the authMiddleware function checks if the user is authenticated by calling the userIsAuthenticated function (which is not shown here). If the user is not authenticated, the middleware function redirects them to the login page. If the user is authenticated, the middleware function calls the next middleware function or the final handler.

gorilla/mux as Error Handling Middleware in Go

Another common use case for middleware is error handling. Developers can create a middleware function that catches errors thrown by the final handler and returns a custom error message to the client. Here’s an example:

func errorHandler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                http.Error(w, "Oops! Something went wrong.",             http.StatusInternalServerError)
        }
        }()
        next.ServeHTTP(w, r)
    })
}

router := mux.NewRouter()
router.Use(errorHandler)
router.HandleFunc("/create", createResource).Methods("POST")

Here, the errorHandler function wraps the final handler in a deferred function that catches any panics and returns a custom error message to the client. If the final handler returns without throwing an error, the middleware function calls the next middleware function.

gorilla/mux as Parameter Validation Middleware in Go

Developers can also create middleware functions that validate the parameters of incoming requests. For instance, they could create a middleware function that checks if a request contains a valid email address in the query parameters.

func validateEmail(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        email := r.URL.Query().Get("email")
        if !isValidEmail(email) {
            http.Error(w, "Invalid email address", http.StatusBadRequest)
            return
        }
        next.ServeHTTP(w, r)
    })
}

router := mux.NewRouter()
router.Use(validateEmail)
router.HandleFunc("/subscribe", subscribeToNewsletter).Methods("POST")

The validateEmail function extracts the email parameter from the query string and checks if it’s a valid email address. The middleware function returns a 400 Bad Request error if it is invalid. If it’s valid, the middleware function calls the next middleware function or the final handler.

Here’s an example of using multiple routes with different middleware functions in Gorilla Mux:

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Check if user is authenticated
        if !userIsAuthenticated(r) {
            http.Redirect(w, r, "/login", http.StatusSeeOther)
            return
        }
        // Call the next middleware function or final handler
        next.ServeHTTP(w, r)
    })
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

router := mux.NewRouter()

// Middleware for /dashboard route
dashboardMiddleware := mux.NewRouter().PathPrefix("/dashboard").Subrouter()
dashboardMiddleware.Use(authMiddleware)

// Middleware for /api route
apiMiddleware := mux.NewRouter().PathPrefix("/api").Subrouter()
apiMiddleware.Use(loggingMiddleware)

// Routes for /dashboard route
dashboardMiddleware.HandleFunc("/home", showDashboard).Methods("GET")
dashboardMiddleware.HandleFunc("/profile", showProfile).Methods("GET")

// Routes for /api route
apiMiddleware.HandleFunc("/users", listUsers).Methods("GET")
apiMiddleware.HandleFunc("/products", listProducts).Methods("GET")

// Register subrouters with main router
router.PathPrefix("/dashboard").Handler(dashboardMiddleware)
router.PathPrefix("/api").Handler(apiMiddleware)

We’re using two middleware functions: authMiddleware for the /dashboard route and loggingMiddleware for the /api route here. We’re creating subrouters for each route using the mux.NewRouter().PathPrefix() method, and attaching the appropriate middleware functions to each subrouter using the Use() method.

After setting up the middleware and subrouters, we’re defining the handler functions for each route using HandleFunc(). Finally, we’re registering each subrouter with the main router using the PathPrefix() method, which matches any URL path that starts with the given prefix.

With this setup, requests to /dashboard/home and /dashboard/profile will be authenticated using the authMiddleware function, while requests to /api/users and /api/products will be logged using the loggingMiddleware function.

Conclusion

Gorilla Mux is a powerful and flexible HTTP router for Go that provides developers with a variety of tools for building web applications. With its support for middleware and subrouters, Gorilla Mux makes it easy to add features like authentication, error handling, and parameter validation to your application.

Middleware functions in Gorilla Mux are used to modify the behavior of a request/response cycle, allowing developers to inject custom logic into the routing process. This can be useful for tasks like authentication, logging, and error handling.

Subrouters in Gorilla Mux allow developers to group routes together and apply middleware to specific groups of routes. As well as, this can be useful for breaking down large applications into smaller, more manageable sections, or for applying different middleware to different sections of your application.

Overall, Gorilla Mux is a versatile and powerful routing library for Go that can help you easily build complex web applications. Whether building a simple API or a complex web application, Gorilla Mux provides the tools you need to get the job done.

Gophers Lab specializes in Golang Development Services. Our team consists of some of the earliest adopters of Golang, who bring their vast expertise to your projects. Hire Golang Developers or outsource Golang projects to one of the top Golang development companies.