Middleware

If you have some code that needs to be run for every request, regardless of
the route that it will eventually end up invoking, you need some way to stack
http.Handlers on top of each other and run them in sequence. This problem is
solved elegantly through middleware packages. Negroni is a popular middleware
package that makes building and stacking middleware very easy while keeping the
composable nature of the Go web ecosystem intact.

Negroni comes with some default middleware such as Logging, Error Recovery, and
Static file serving. So out of the box Negroni will provide you with a lot of
value without a lot of overhead.

The example below shows how to use a Negroni stack with the built in middleware
and how to create your own custom middleware.

  1. package main
  3. import (
  4.     "log"
  5.     "net/http"
  7.     "github.com/codegangsta/negroni"
  8. )
  10. func main() {
  11.     // Middleware stack
  12.     n := negroni.New(
  13.         negroni.NewRecovery(),
  14.         negroni.HandlerFunc(MyMiddleware),
  15.         negroni.NewLogger(),
  16.         negroni.NewStatic(http.Dir("public")),
  17.     )
  19.     n.Run(":8080")
  20. }
  22. func MyMiddleware(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
  23.     log.Println("Logging on the way there...")
  25.     if r.URL.Query().Get("password") == "secret123" {
  26.         next(rw, r)
  27.     } else {
  28.         http.Error(rw, "Not Authorized", 401)
  29.     }
  31.     log.Println("Logging on the way back...")
  32. }

Exercises

  1. Think of some cool middleware ideas and try to implement them using Negroni.
  2. Explore how Negroni can be composed with github.com/gorilla/mux using the http.Handler interface.
  3. Play with creating Negroni stacks for certain groups of routes instead of the entire application.