Gorilla mux custom middleware

I am using gorilla mux for manage routing. What I am missing is to integrate a middleware between every request.

For example

package main

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

func HomeHandler(response http.ResponseWriter, request *http.Request) {

	fmt.Fprintf(response, "Hello home")
}

func main() {

	port := 3000
	portstring := strconv.Itoa(port)

	r := mux.NewRouter()
	r.HandleFunc("/", HomeHandler)
	http.Handle("/", r)

	log.Print("Listening on port " + portstring + " ... ")
	err := http.ListenAndServe(":"+portstring, nil)
	if err != nil {
		log.Fatal("ListenAndServe error: ", err)
	}
}

Every incoming request should pass through the middleware. How can I integrate here a midleware?

Update

I will use it in combination with gorilla/sessions, and they say:

> Important Note: If you aren't using gorilla/mux, you need to wrap your
> handlers with context.ClearHandler as or else you will leak memory! An
> easy way to do this is to wrap the top-level mux when calling
> http.ListenAndServe:

How can I prevent this scenario?

Just create a wrapper, it's rather easy in Go:

func HomeHandler(response http.ResponseWriter, request *http.Request) {

	fmt.Fprintf(response, "Hello home")
}

func Middleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Println("middleware", r.URL)
		h.ServeHTTP(w, r)
	})
}
func main() {
	r := mux.NewRouter()
	r.HandleFunc("/", HomeHandler)
	http.Handle("/", Middleware(r))
}

Mux has an official way of doing it
look on this example

// a regular middleware
func Middleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// do stuff before the handlers
		h.ServeHTTP(w, r)
		// do stuff after the hadlers

	})
}

// if you want to pass data into the middleware 
func Middleware2(s string) mux.MiddlewareFunc {
	return func(h http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			// do stuff
			fmt.Println(s)
			h.ServeHTTP(w, r)
		})
	}
}

func main() {
	router := mux.NewRouter()


	router.Use(Middleware)
	//you can apply it to a sub-router too
	subRouter := router.PathPrefix("/sub_router/").Subrouter()
	subRouter.Use(Middleware2("somePrams"))
	// Add more middleware if you need, call router.Use Again
	router.Use(Middleware3, Middleware4, Middleware5)

	_ = http.ListenAndServe(":80", router)
}

the official doc on the mux website

I'm not sure why @OneOfOne chose to chain router into the Middleware, I think this is slight better approach:

func main() {
    r.Handle("/",Middleware(http.HandlerFunc(homeHandler)))
    http.Handle("/", r)
}

func Middleware(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    h.ServeHTTP(w, r)
})}

If you want to apply a middleware chain to all routes of a router or subrouter you can use a fork of Gorilla mux https://github.com/bezrukovspb/mux

subRouter := router.PathPrefix("/use-a-b").Subrouter().Use(middlewareA, middlewareB)
subRouter.Path("/hello").HandlerFunc(requestHandlerFunc)

You might consider a middleware package such as negroni.

1: http://negroni.codegangsta.io/ "negroni"