Better routing with Go’s standard library.

Improving the routing definitions

In the previous version of the router I had a overly simplified approach, which required to check for the http method in the handler, to be able to handle different http methods. In order to improve that, I have introduced a simple router implementation. This allows for defining the routes, see the init function in the server.go file.

And here is the router itself:

    package router

    import (
      "context"
      "net/http"
      "regexp"
      "strings"
    )

    var Routes = []Route{}

    type Route struct {
      method  string
      regex   *regexp.Regexp
      handler http.HandlerFunc
    }

    type CtxKey struct{}

    func CreateRoute(method, pattern string, handler http.HandlerFunc) Route {
      return Route{method, regexp.MustCompile("^" + pattern + "$"), handler}
    }

    func Serve(w http.ResponseWriter, r *http.Request) {
      var allow []string
      for _, route := range Routes {
        matches := route.regex.FindStringSubmatch(r.URL.Path)
        if len(matches) > 0 {
          if r.Method != route.method {
            allow = append(allow, route.method)
            continue
          }
          ctx := context.WithValue(r.Context(), CtxKey{}, matches[1:])
          route.handler(w, r.WithContext(ctx))
          return
        }
      }
      if len(allow) > 0 {
        w.Header().Set("Allow", strings.Join(allow, ", "))
        http.Error(w, "405 method not allowed", http.StatusMethodNotAllowed)
        return
      }
      http.NotFound(w, r)
    }

  

The server.go has not changed that much beyond the router definitions. I introduced a config to handle environment variables more easily and in this particular case to determine if the server is running in development mode.

    package main

    import (
      "embed"
      "html/template"
      "log"
      "main/config"
      "main/handlers"
      "main/middlewares"
      "main/router"
      "net/http"
    )

    //go:embed templates
    var embededTemplates embed.FS

    //go:embed public
    var embededPublic embed.FS

    var reloaded = false

    // public HTML route middleware stack
    var publicHTMLStack = []middlewares.Middleware{
      middlewares.Logger,
    }

    func init() {
      var staticServer http.Handler
      var stripPrefix string

      router.Routes = []router.Route{
        // HTML routes
        router.CreateRoute("GET", "/", middlewares.CompileMiddleware(handlers.Home, publicHTMLStack)),
      }

      // only do this in development environment
      if config.IsDevelopment() {
        staticServer = http.FileServer(http.Dir("./public"))
        stripPrefix = "/public/"
      } else {
        staticServer = http.FileServer(http.FS(embededPublic))
        stripPrefix = "/"
      }
      router.Routes = append(router.Routes, router.CreateRoute("GET", "/public/.*", http.StripPrefix(stripPrefix, staticServer).ServeHTTP))
    }

    func main() {
      // pre-parse templates, embedded in server binary
      handlers.Tmpl = template.Must(template.ParseFS(embededTemplates, "templates/layouts/*.html", "templates/partials/*.html"))

      // mux/router definition
      mux := http.HandlerFunc(router.Serve)

      // start the server
      log.Fatal(http.ListenAndServe(":8000", mux))
    }
    

I have also updated the middleware as the routing logic changed a bit, see the updated version below.

      package middlewares

      import (
        "log"
        "net/http"
        "time"
      )

      // type for chaining
      type Middleware func(http.HandlerFunc) http.HandlerFunc

      // basically thisd is middleware chaining
      func CompileMiddleware(h http.HandlerFunc, m []Middleware) http.HandlerFunc {
        if len(m) < 1 {
          return h
        }

        wrapped := h

        // loop in reverse to preserve middleware order
        for i := len(m) - 1; i >= 0; i-- {
          wrapped = m[i](wrapped)
        }

        return wrapped
      }

      func Logger(next http.HandlerFunc) http.HandlerFunc {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
          start := time.Now()
          next.ServeHTTP(w, r)
          log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
        })
      }
    

If you would like to take a look at the code, you may find it here on GitHub.