Using Function Types and Interfaces to Build Flexible HTTP Handlers in Go

In Go's standard library, especially the net/http package, a concise programming pattern combines function types with interfaces to create flexible and extensible code, improving reuse, testing, and overall code quality.

Basic Concepts

Interface: a set of methods; any type implementing those methods satisfies the interface.

Type definition: Go allows defining new types, including function signatures.

Method: methods can be defined on structs, basic types, or even function types.

Practical Analysis

The net/http package defines the Handler interface:

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

Any type with a ServeHTTP method can act as an HTTP request handler. Traditionally a struct is used, but this adds boilerplate.

Go provides the HandlerFunc function type whose signature matches ServeHTTP, and implements ServeHTTP by calling the underlying function:

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

This allows a plain function to satisfy the Handler interface without defining a struct.

Practical Code

Example:

package main

import (
    "net/http"
    "fmt"
)

// some common logic
func helloHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello world"))
}

func main() {
    // http.HandlerFunc converts helloHandler to a Handler
    http.Handle("/hello", http.HandlerFunc(helloHandler))

    // equivalent shortcut
    http.HandleFunc("/hello", helloHandler)

    http.ListenAndServe(":8080", nil)
}

The code registers the function with the default ServeMux, which implements Handler, so the server can route requests to the function.

Underlying implementations of HandleFunc and Handle illustrate how the function is wrapped into a HandlerFunc and stored in the mux.

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.register(pattern, HandlerFunc(handler))
}

func Handle(pattern string, handler Handler) {
    DefaultServeMux.register(pattern, handler)
}

ServeMux's ServeHTTP method looks up the handler for the request URL and invokes its ServeHTTP method.

type ServeMux struct {
    // fields omitted
}

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    // find handler and call h.ServeHTTP(w, r)
}

Conclusion

Using function types to satisfy interfaces yields concise, readable, and reusable code, reduces boilerplate, and simplifies testing. The pattern can be extended to build richer web frameworks.

Benefits

Conciseness and readability.

Flexibility to adapt to changing requirements.

Reduced boilerplate.

Enhanced code reuse.

Simplified unit testing.

A final simple example demonstrates adapting a function to an interface using an Operation type.

package main

import "fmt"

type Operation interface {
    Execute(a, b int) int
}

type OperationFunc func(a, b int) int

func (f OperationFunc) Execute(a, b int) int { return f(a, b) }

func Calculate(a, b int, op Operation) int { return op.Execute(a, b) }

func main() {
    addition := OperationFunc(func(a, b int) int { return a + b })
    subtraction := OperationFunc(func(a, b int) int { return a - b })
    fmt.Println("Addition:", Calculate(10, 5, addition))
    fmt.Println("Subtraction:", Calculate(10, 5, subtraction))
}