Concept: Martini like Go Meta Framework Using Code Generation.

output.go

package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
)

type testHandler struct {
	id   int
	name string
}

func (h *testHandler) Handle(w http.ResponseWriter, r *http.Request, params map[string]string, id int, name string) {
	param := params["param"]
	fmt.Fprintf(w, "Hello, %s (%d): param: %s", name, id, param)
}

func (h *testHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	h.Handle(w, r, params, h.id, h.name)
}

func BuildtestHandler(id int, name string) *testHandler {
	return &testHandler{id, name}
}

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

	id := 1
	name := "first"

	rtr.Handle("/{param}", BuildtestHandler(id, name)).Methods("GET")

	http.Handle("/", rtr)

	log.Println("Listening...")
	http.ListenAndServe(":3000", nil)
}

src.go

package main

import (
	"fmt"
	"net/http"
)

func main() {

	m := rickey.New()
	id := 1
	name := "first"
	
	m.Use(id)
	m.Use(name)

	//Handler: test
	m.Get("/{param}", func(w http.ResponseWriter, r *http.Request, params rickey.Params, id int, name string) {
		param := params["param"]
		fmt.Fprintf(w, "Hello, %s (%d): New text: %s", name, id, param)
	})
	
	m.Run(":3000")
}

The idea here is that the end result should be perfectly human readable and structured based on Go's http.Handler. The middlewares will be just http.Handler's too.

As we are using code generation to avoid typing too much, might as well do it all with http.Handlers without even using Gorilla, but undoubtedly there is a lot that can be learned from the Gorilla code base to create a better solution.