The Go net/http package provides a flexible foundation for building HTTP servers. At its core are interfaces and types that manage request routing, handling, and server configuration. This article explores the key components: Handler, HandlerFunc, ServeMux, and the Server type.

Handler and HandlerFunc

The http.Handler interface is fundamental:

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

Any type implementing ServeHTTP can serve HTTP requests. For convenience, function types can also act as handlers via http.HandlerFunc, which adapts a function with the correct signature into a Handler:

type HandlerFunc func(http.ResponseWriter, *http.Request)

This allows regular functions to be converted into handlers without defining a struct.

Using a Custom Handler Type

A struct can implement ServeHTTP to maintain state or encapsulate logic:

import ( "fmt" "log" "net/http" "sync" )

type counter struct { mu sync.Mutex count int }

func (c *counter) ServeHTTP(w http.ResponseWriter, r *http.Request) { c.mu.Lock() defer c.mu.Unlock() c.count++ fmt.Fprintf(w, "Request count: %d\n", c.count) }

func main() { http.Handle("/count", &counter{}) log.Fatal(http.ListenAndServe(":8080", nil)) }

</details>#### Using HandlerFunc

For simple endpoints, passing a closure to `HandleFunc` is more concise:

<details><summary>Function-based handlers</summary>```
package main

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

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/" {
            http.NotFound(w, r)
            return
        }
        io.WriteString(w, "Home page\n")
    })

    http.HandleFunc("/api/greet", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "Hello from API!\n")
    })

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

http.ServeMux routes incoming requests to the appropriate handler based on URL patterns. It implements the Handler interface, meaning it can be passed directly to server functions.

You can create a custom multiplexer using http.NewServeMux():

mux := http.NewServeMux()
mux.HandleFunc("/api/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "API path: %s\n", r.URL.Path)
})
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("assets"))))

The Handler method of ServeMux returns the matched handler and pattern for a given request, enabling introspection.

Customizing the Server with http.Server

The http.Server struct allows fine-grained control over server behavior:

type Server struct {
    Addr           string
    Handler        http.Handler
    ReadTimeout    time.Duration
    WriteTimeout   time.Duration
    IdleTimeout    time.Duration
    MaxHeaderBytes int
    TLSConfig      *tls.Config
    // ... additional fields
}

This enables setting timeouts, enabling TLS, managing connections, and injecting custom handlers.

Example: Configured Server Instance

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Welcome!")
    })

    srv := &http.Server{
        Addr:         ":8000",
        Handler:      mux,
        ReadTimeout:  30 * time.Second,
        WriteTimeout: 30 * time.Second,
        IdleTimeout:  120 * time.Second,
    }

    log.Fatal(srv.ListenAndServe())
}

Using a custom Server instance allows graceful shutdown, TLS setup, and integration with context-based cnacellation.

Graceful Shutdown Example

ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()

go func() {
    sigint := make(chan os.Signal, 1)
    signal.Notify(sigint, os.Interrupt)
    <-sigint
    srv.Shutdown(ctx)
}()

log.Fatal(srv.ListenAndServe())