The net/http Package

mux := http.NewServeMux()

mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "user %s", r.PathValue("id"))
})
mux.HandleFunc("DELETE /users/{id}", func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusNoContent)
})
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static"))))

srv := &http.Server{
    Addr:        ":8080",
    Handler:     mux,
    ReadTimeout: 5 * time.Second,
}
go srv.ListenAndServe()

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

if err := srv.Shutdown(ctx); err != nil {
    log.Println("forced close:", err)
}

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    id := r.PathValue("id")

    if err := r.ParseForm(); err != nil {
        http.Error(w, "bad form", http.StatusBadRequest)
        return
    }
    q := r.Form.Get("q")

    body, err := io.ReadAll(r.Body)
    ...
}

w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "no-store")

w.WriteHeader(http.StatusAccepted)

w.Write([]byte(`{"queued":true}`))

type greeter struct{ name string }

func (g greeter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "hello,", g.name)
}

func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %s", r.Method, r.URL.Path, time.Since(start))
    })
}

mux.Handle("/greet", logging(greeter{name: "world"}))

func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        next.ServeHTTP(w, r)
    })
}

var client = &http.Client{Timeout: 10 * time.Second}

req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
    return err
}

resp, err := client.Do(req)
if err != nil {
    return err
}
defer resp.Body.Close()

resp, err := client.Do(req)
if err != nil {
    return err
}
defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {
    return fmt.Errorf("unexpected status %s", resp.Status)
}

b, err := io.ReadAll(resp.Body)
fmt.Println(len(b), resp.Header.Get("Content-Type"))

h := w.Header()
h.Set("Content-Type", "text/plain")
h.Add("Set-Cookie", "a=1")
h.Add("Set-Cookie", "b=2")

fmt.Println(h.Get("Content-Type")) // text/plain
fmt.Println(h.Values("Set-Cookie")) // [a=1 b=2]

fmt.Println(r.Header.Get("user-agent")) // canonicalized for you

http.SetCookie(w, &http.Cookie{
    Name:     "session",
    Value:    token,
    Path:     "/",
    MaxAge:   3600,
    HttpOnly: true,
    Secure:   true,
    SameSite: http.SameSiteLaxMode,
})

if c, err := r.Cookie("session"); err == nil {
    fmt.Println(c.Value)
}

rc := http.NewResponseController(w)
w.Header().Set("Content-Type", "text/event-stream")

for i := 0; i < 3; i++ {
    fmt.Fprintf(w, "data: tick %d\n\n", i)
    if err := rc.Flush(); err != nil {
        return // the client went away
    }
}

rc.SetWriteDeadline(time.Now().Add(time.Minute))

hj, ok := w.(http.Hijacker)
if !ok {
    http.Error(w, "not supported", http.StatusInternalServerError)
    return
}

conn, bufrw, err := hj.Hijack()
if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
}
defer conn.Close()

bufrw.WriteString("HTTP/1.1 101 Switching Protocols\r\n\r\n")
bufrw.Flush()

f, ok := w.(http.Flusher)
if !ok {
    return
}

w.Write([]byte("partial\n"))
f.Flush()

type addAuth struct {
    token string
    next  http.RoundTripper
}

func (a addAuth) RoundTrip(req *http.Request) (*http.Response, error) {
    r := req.Clone(req.Context())
    r.Header.Set("Authorization", "Bearer "+a.token)
    return a.next.RoundTrip(r)
}

client := &http.Client{
    Transport: addAuth{token: tok, next: http.DefaultTransport},
    Timeout:   10 * time.Second,
}

jar, err := cookiejar.New(nil)
if err != nil {
    log.Fatal(err)
}

client := &http.Client{Jar: jar, Timeout: 10 * time.Second}