Controllers

Controllers are a fairly familiar topic in other web development communities.
Since most web developers rally around the mighty net/http interface, not many
controller implementations have caught on strongly. However, there is great
benefit in using a controller model. It allows for clean, well defined
abstractions above and beyond what the net/http handler interface can alone
provide.

Handler Dependencies

In this example we will experiment with building our own controller
implementation using some standard features in Go. But first, lets start with
the problems we are trying to solve. Say we are using the render library that
we talked about in previous chapters:

  1. var Render = render.New(render.Options{})

If we want our http.Handlers to be able access our render.Render instance,
we have a couple options.

1. Use a global variable: This isn’t too bad for small programs, but when
the program gets larger it quickly becomes a maintenance nightmare.

2. Pass the variable through a closure to the http.Handler: This is a
great idea, and we should be using it most of the time. The implementation ends
up looking like this:

  1. func MyHandler(r *render.Render) http.Handler {
  2.   return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
  3.     // now we can access r
  4.   })
  5. }

Case for Controllers

When your program grows in size, you will start to notice that many of your
http.Handlers will share the same dependencies and you will have a lot of
these closurized http.Handlers with the same arguments. The way I like to
clean this up is to write a little base controller implementation that affords
me a few wins:

  1. Allows me to share the dependencies across http.Handlers that have similar goals or concepts.
  2. Avoids global variables and functions for easy testing/mocking.
  3. Gives me a more centralized and Go-like mechanism for handling errors.

The great part about controllers is that it gives us all these things without
importing an external package! Most of this functionality comes from clever use
of the Go feature set, namely Go structs and embedding. Let’s take a look at the
implementation.

  1. package main
  3. import "net/http"
  5. // Action defines a standard function signature for us to use when creating
  6. // controller actions. A controller action is basically just a method attached to
  7. // a controller.
  8. type Action func(rw http.ResponseWriter, r *http.Request) error
  10. // This is our Base Controller
  11. type AppController struct{}
  13. // The action function helps with error handling in a controller
  14. func (c *AppController) Action(a Action) http.Handler {
  15.     return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
  16.         if err := a(rw, r); err != nil {
  17.             http.Error(rw, err.Error(), 500)
  18.         }
  19.     })
  20. }

Thats it! That is all the implementation that we need to have the power of
controllers at our fingertips. All we have left to do is implement an example
controller:

  1. package main
  3. import (
  4.     "net/http"
  6.     "gopkg.in/unrolled/render.v1"
  7. )
  9. type MyController struct {
  10.     AppController
  11.     *render.Render
  12. }
  14. func (c *MyController) Index(rw http.ResponseWriter, r *http.Request) error {
  15.     c.JSON(rw, 200, map[string]string{"Hello": "JSON"})
  16.     return nil
  17. }
  19. func main() {
  20.     c := &MyController{Render: render.New(render.Options{})}
  21.     http.ListenAndServe(":8080", c.Action(c.Index))
  22. }

Exercises

  1. Extend MyController to have multiple actions for different routes in your application.
  2. Play with more controller implementations, get creative.
  3. Override the Action method on MyController to render a error HTML page.