gorilla/mux

Middleware in mux are functions with the signature type MiddlewareFunc func(http.Handler) http.Handler. They are executed in the order they are added via Router.Use(). A middleware can intercept a request, perform actions (like logging or authentication), and then either call next.ServeHTTP(w, r) to continue the chain or stop the chain by returning early (e.g., writing an error response).

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

r := mux.NewRouter()
r.Use(loggingMiddleware)
r.HandleFunc("/", handler)

Subrouters allow you to group routes that share common matching requirements (like a specific Host or PathPrefix). This optimizes request matching and allows you to create namespaces. When a subrouter is created from a PathPrefix, the inner routes use that prefix as their base path.

r := mux.NewRouter()
// All routes in 's' will only match if the host is www.example.com
s := r.Host("www.example.com").Subrouter()
s.HandleFunc("/products/", ProductsHandler)

// Using PathPrefix to create a namespace
api := r.PathPrefix("/api").Subrouter()
api.HandleFunc("/users", UsersHandler) // matches /api/users

To install the gorilla/mux package, use the following Go command with a correctly configured Go toolchain:

go get -u github.com/gorilla/mux

To serve static files, use PathPrefix() combined with http.StripPrefix and http.FileServer. The PathPrefix acts as a wildcard for everything following the prefix.

r := mux.NewRouter()
// Serves files from the local directory under the /static/ URL path
r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir("./static"))))

You can register URL paths to handlers using r.HandleFunc(). Paths can include variables defined with the {name} or {name:pattern} syntax. If no pattern is provided, the variable matches everything until the next slash. Use mux.Vars(r) to retrieve a map of these variables from the request.

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/products/{key}", ProductHandler)
    r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)
    http.Handle("/", r)
}

func ArticleHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    category := vars["category"]
    id := vars["id"]
    // ...
}

To build a basic HTTP server using mux, initialize a new router with mux.NewRouter(). You define routes by associating a path pattern with a handler function using r.HandleFunc(path, handler). Finally, pass the router instance to http.ListenAndServe to start the server.

Note: The router implements the http.Handler interface, so it can be used anywhere a standard Go handler is expected.

package main

import (
    "net/http"
    "log"
    "github.com/gorilla/mux"
)

func YourHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Gorilla!\n"))
}

func main() {
    r := mux.NewRouter()
    // Routes consist of a path and a handler function.
    r.HandleFunc("/", YourHandler)

    // Bind to a port and pass our router in
    log.Fatal(http.ListenAndServe(":8000", r))
}

You can name routes using .Name("name") and then generate URLs (reverse routing) using r.Get("name"). The .URL(...) method takes key/value pairs for the route variables. This ensures generated URLs always match the registered route patterns.

• URL(key, value...): Builds the full URL (including host, path, and queries).
• URLHost(key, value...): Builds only the host part.
• URLPath(key, value...): Builds only the path part.
• GetVarNames(): Returns the names of all required variables for a route.

r := mux.NewRouter()
r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).Name("article")

// Build the full URL
url, err := r.Get("article").URL("category", "technology", "id", "42")
// Result: /articles/technology/42

// Get variable names
names := r.Get("article").GetVarNames()
// Result: [category id]

The mux.CORSMethodMiddleware simplifies setting the Access-Control-Allow-Methods header. It automatically sets the header to match the methods defined in your route matchers.

Important: You must include an OPTIONS method matcher on the route for the middleware to function correctly. You are still responsible for setting other CORS headers like Access-Control-Allow-Origin in your actual handler.

r := mux.NewRouter()
// Must include OPTIONS in the methods
r.HandleFunc("/foo", fooHandler).Methods("GET", "POST", "OPTIONS")

r.Use(mux.CORSMethodMiddleware(r))

func fooHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Access-Control-Allow-Origin", "*")
    if r.Method == http.MethodOptions {
        return
    }
    w.Write([]byte("foo"))
}

The Walk method allows you to iterate over every route registered in the router. This is useful for debugging or inspecting the routing table. The callback function receives the *mux.Route, the *mux.Router, and a slice of ancestors (the route hierarchy).

err := r.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
    path, _ := route.GetPathTemplate()
    fmt.Println("Route path template:", path)
    return nil
})

Use mux.NewRouter() to create a new instance of a Router. The Router implements the http.Handler interface, allowing it to be passed directly to http.Handle or http.ListenAndServe. It manages route registration, matching, and middleware execution.

var router = mux.NewRouter()

func main() {
    http.Handle("/", router)
    http.ListenAndServe(":8080", nil)
}