ServeMux is an HTTP request multiplexer. The HandleFunc we used in the preceding section is actually a method of ServeMux. By creating a new ServeMux, we can handle multiple routes. Before that, we can also create our own multiplexer. A multiplexer just handles the logic of separating routes with a function called ServeHTTP. So if we create a new struct with the ServeHTTP method, it can do the job.

Consider a route as a key in a dictionary (map), then the handler as its value. The router finds the handler from the route and tries to execute the ServeHTTP function. Let us create a program called customMux.go and see this implementation in action:

package main
import (
    "fmt"
    "math/rand"
    "net/http"
)
// CustomServeMux is a struct which can be a multiplexer
type CustomServeMux struct {
}
// This is the function handler to be overridden
func (p *CustomServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/" {
        giveRandom(w, r)
        return
    }
    http.NotFound(w, r)
    return
}
func giveRandom(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Your random number is: %f", rand.Float64())
}
func main() {
    // Any struct that has serveHTTP function can be a multiplexer
    mux := &CustomServeMux{}
    http.ListenAndServe(":8000", mux)
}

In this code, we are creating a custom struct called CustomServeMux, which is going to take care of our routing. We implemented a function called ServeHTTP in order to capture the request and write a response back to it. The fmt package is usually used to create strings. Fprinf composes the string out of supplied parameters.

In the main function, we are creating an instance of our CustomServeMux and passing it to the ListenAndServe function on http. "math/rand" is the library that takes care of generating random numbers. This basic foundation is going to be helpful for us when we discuss adding authentication to our API server.