Golang’s net/http package can be used to build a web server in a minutes. It packs in a pretty wide use of Golang concepts like functions, interfaces and types to achieve this.

Here is a basic web server using Go:

package main 
import ( 
  "fmt" 
  "net/http" 
) 
func main() { 
   http.HandleFunc("/", handlerHelloWorld)     
   http.ListenAndServe(":8082", nil) 
} 

func handlerHelloWorld(w http.ResponseWriter, r *http.Request){
    fmt.Fprintf(w, "Hello world") 
} 

If we run the above server we can make a GET request and the server will print “Hello World”.

What we need to understand that in the background, the package runs a ServeMux to map the url to the handler.

What is ServeMux?

A ServeMux is a HTTP request multiplexer or router that  matches the incoming requests with a set of registered patterns and  calls  the associated handler for that pattern.

http.ListenAndServe has the following signature

func ListenAndServe(addr string, handler Handler) error

If we pass nil as the handler, as we did in or basic server example, the DefaultServeMux will be used.

ServeMux struct contains the following four vital functions that are key to the working of the http package:

func (mux *ServeMux) Handle(pattern string, handler Handler)
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)

What is a Handler?

Notice that ServeMux has a function named Handler that takes in a reference to a http.Request param and returns a object of type Handler.   Made my head spin a bit when I first saw that!

But looking under the hood, it turns out, http.Handler is simply an interface. Any object can be made a handler as long as it implements the ServeHTTP function with the following signature.

 ServeHTTP(ResponseWriter, *Request)

So essentially the default ServeMux is a type of Handler since it implements ServeHTTP.

HandleFunc and Handle

In our simple server code above, we did not define a Handler that implements ServeHTTP nor did we define a ServeMux. Instead we called HandleFunc and the function that would handle the response.

This is the source code for HandleFunc in the net/http package

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

Internally this calls the DefaultServerMux’s HandleFunc. If you take a look at the implementation of HandleFunc within ServeMux, here is what you’ll find:

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {   
   if handler == nil {   
         panic("http: nil handler")   
   }    
   mux.Handle(pattern, HandlerFunc(handler))   
}

From the net/http source, we find that HandlerFunc type is an adapter to allows the use of an ordinary functions as HTTP handlers.

type HandlerFunc func(ResponseWriter, *Request)       
   
// ServeHTTP calls f(w, r).  
 func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {    f(w, r)   
}

The HandlerFunc makes it possible for us to pass in any function to make it a Handler. So in our simple server example above, we could change the HandleFunc call to a call to the Handle function. All we would have to do is wrap it in  HandlerFunc.

http.Handle("/", http.HandlerFunc(indexHandlerHelloWorld))

The Handle function is used when we want to use a custom Handler in our code. 

To demonstrate the use of some of these concepts, here is a simple example of chat server that will receive messages and broadcast them. It uses a Handler that is passed to a ServeMux. 

package main
 import (
     "encoding/json"
     "fmt"
     "io/ioutil"
     "log"
     "net/http"
 )

 type MessageDigest struct {
     Text   string json:"message"
     ToUser string json:"to"
 }
 type ChatHandler struct{}
 func (c *ChatHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     if r.Body == nil {
         return
     }
     var msg MessageDigest
     body, err := ioutil.ReadAll(r.Body)
     if err != nil {
        http.StatusText(http.StatusInternalServerError),http.StatusInternalServerError)
         return
     }
     err = json.Unmarshal(body, msg)
     if err != nil {
         http.Error(w, http.StatusText(http.StatusInternalServerError),http.StatusInternalServerError)
         return
     }
     w.WriteHeader(http.StatusOK)
     fmt.Println("Message for ", msg.ToUser, ": ", msg.Text)
 }


 func main() {
     mux := http.NewServeMux()
     chatHandler := new(ChatHandler)
     mux.Handle("/ws", chatHandler)
     log.Fatal(http.ListenAndServe(":8080", mux))
 }