HTTP and Networking

Updated

July 30, 2026

Overview

Go’s net/http package provides a complete HTTP client and server implementation.

HTTP Client

// Simple GET
resp, err := http.Get("https://api.example.com/data")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

body, _ := io.ReadAll(resp.Body)

Custom Request

req, _ := http.NewRequest("POST", url, bytes.NewBuffer(data))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+token)

client := &http.Client{Timeout: 10 * time.Second}
resp, err := client.Do(req)

With Context

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

req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := http.DefaultClient.Do(req)

HTTP Server

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

JSON API

func userHandler(w http.ResponseWriter, r *http.Request) {
    user := User{Name: "Alice"}

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

Middleware

func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL)
        next.ServeHTTP(w, r)
    })
}

http.Handle("/", logging(http.HandlerFunc(handler)))

ServeMux

mux := http.NewServeMux()
mux.HandleFunc("/users", usersHandler)
mux.HandleFunc("/posts", postsHandler)

http.ListenAndServe(":8080", mux)

Static Files

fs := http.FileServer(http.Dir("./static"))
http.Handle("/static/", http.StripPrefix("/static/", fs))

Summary

Function	Purpose
`http.Get()`	Simple GET request
`http.Post()`	Simple POST request
`http.NewRequest()`	Custom request
`http.HandleFunc()`	Register handler
`http.ListenAndServe()`	Start server

Worked example

JSON POST API with middleware, tested via httptest.NewServer.

Save as main.go. Then:

go mod init example
go run .

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/http/httptest"
    "strings"
)

type echoReq struct {
    Msg string `json:"msg"`
}

type echoResp struct {
    Echo string `json:"echo"`
}

func withJSON(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.Handle("POST /echo", withJSON(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var req echoReq
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Msg == "" {
            w.WriteHeader(http.StatusBadRequest)
            _ = json.NewEncoder(w).Encode(map[string]string{"error": "bad json"})
            return
        }
        _ = json.NewEncoder(w).Encode(echoResp{Echo: strings.ToUpper(req.Msg)})
    })))

    srv := httptest.NewServer(mux)
    defer srv.Close()

    res, err := http.Post(srv.URL+"/echo", "application/json", strings.NewReader(`{"msg":"hi"}`))
    if err != nil {
        panic(err)
    }
    body, _ := io.ReadAll(res.Body)
    res.Body.Close()
    fmt.Println("status:", res.StatusCode)
    fmt.Println("body:", strings.TrimSpace(string(body)))
}

Expected output:

status: 200
body: {"echo":"HI"}

More examples

httptest.NewRecorder unit test of a pure handler (no listening socket).

package main

import (
    "fmt"
    "net/http"
    "net/http/httptest"
)

func health(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    _, _ = w.Write([]byte("ok"))
}

func main() {
    rec := httptest.NewRecorder()
    req := httptest.NewRequest(http.MethodGet, "/health", nil)
    health(rec, req)
    fmt.Println(rec.Code, rec.Body.String())
}