Nest Functions From Slice

I am building a Go web application that supports various middleware functions when handling routing. I'm trying to stick to net/http as much as possible and was wondering how I might accomplish this without using middleware libraries like negroni.

Essentially what I would like to do is to be able to provide a slice of middleware functions, say one for logging, one for checking for a valid JWT, and then finally the handler to handle the request.

I am able to do this with negroni fairly simply by defining the following struct:

// Route ..
type Route struct {
  Method     string
  Path       string
  Middleware []negroni.Handler
  Handler    http.HandlerFunc
}

and then defining a route like:

var commonRoutes = []Route{
	{
		Method:     "GET",
		Path:       "/info",
		Middleware: []negroni.Handler{negroni.HandlerFunc(middleware.CheckCache), negroni.HandlerFunc(middleware.Authenticated), negroni.NewLogger()},
		Handler:    handlers.APIInfo,
	},
}

Finally when I boot up my server, I import the list of routes and register them like so:

for _, r := range routes {
    
  handler := append(r.Middleware, negroni.Wrap(r.Handler))
    
  router.Handle(r.Path, negroni.New(handler...)).Methods(r.Method)
}

And this works perfectly.

Any idea how I might be able to do this with just the standard net/http signature and way of defining middleware handlers that look like this:

http.Handle("/", middlewareOne(middlewareTwo(finalHandler)))

Thank you

func Auth(n http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      log.Printf("Start")
      n.ServeHTTP(w, r)
      log.Printf("End")
  })
}

func processReq(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("Success"))
}


func main() {
  handler := http.HandlerFunc(processReq)

  http.Handle("/",Auth(handler))
  http.ListenAndServe(":8000", nil)
}

can be done using http.handler

Simple. You define each handler like so:

// So I don't have to type it over and over...
type HTTPHandler func(w http.ResponseWriter, r *http.Request)

func Handler1(next HTTPHandler) HTTPHandler {
    return func(w http.ResponseWriter, r *http.Request){
        // Do stuff
        
        if next != nil {
            next(w, r)
        }
    }
}

// Handler2 ... HandlerN defined in the same basic way.

// Chaining:
http.Handle("/", Handler1(Handler2(nil)))

Each handler takes the next handler and returns a closure that does whatever you want plus calling the next handler. If you need lots of these it may make sense to write a helper similar to this one:

func MakeHandler(worker, next HTTPHandler) HTTPHandler {
    return func(w http.ResponseWriter, r *http.Request){
        // Maybe have to worker return an error and do standard error
        // handling here? Could simplify your code some depending on
        // what you are doing.
        worker(w, r)
        
        if next != nil {
            next(w, r)
        }
    }
}