Use the net/http package to easily create an HTTP server, register routes through http.HandleFunc and start services with http.ListenAndServe; 2. Customize ServeMux to better manage routes; 3. Middleware can implement logging, authentication and other functions through wrapper processors, supporting combination and reuse; 4. When making requests with http.Client, set timeout, reuse client instances and close response bodies; 5. When handling JSON, set the correct Content-Type, use json.Encoder to send, receive json.Decoder, and handle errors properly; 6. To achieve elegant closure, combine context and Server.Shutdown to ensure that the request being processed is completed; 7. Best practices include avoiding global state and using context Pass request data, limit request body size, verify input and always check errors. Mastering net/http is the basis for building Go Web services, and even using frameworks, it depends on its underlying capabilities.

The net/http package is one of the most powerful and widely used packages in Go's standard library. It provides HTTP client and server implementations that are simple to use yet flexible enough for production applications. Whether you're building a REST API or making external HTTP requests, understanding net/http is essential.

Here's a practical guide to the core features and best practices when working with net/http .

1. Creating an HTTP Server

The simplest way to start an HTTP server in Go is using http.ListenAndServe with http.HandleFunc .

 package main

import (
    "fmt"
    "net/http"
)

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

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("Server starting on :8080...")
    http.ListenAndServe(":8080", nil)
}

• http.HandleFunc registers a function to handle requests for a given route.
• The handler takes two arguments: http.ResponseWriter (to send the response) and *http.Request (the incoming request).
• nil as the second argument to ListenAndServe means use the default http.DefaultServeMux .

For more control, you can create a custom ServeMux :

 mux := http.NewServeMux()
mux.HandleFunc("/api/", apiHandler)
mux.HandleFunc("/static/", staticHandler)
http.ListenAndServe(":8080", mux)

This helps organize routes and avoid global state.

2. Building HTTP Handlers and Middleware

HTTP handlers in Go follow the signature func(http.ResponseWriter, *http.Request) . You can wrap them to create middleware for logging, authentication, or CORS.

Example: Logging Middleware

 func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        fmt.Printf("Received %s request for %s\n", r.Method, r.URL.Path)
        next(w, r)
    }
}

// Use it:
http.HandleFunc("/hello", loggingMiddleware(helloHandler))

• Middleware functions take a handler and return a new one.
• They're composable and reusable across routes.

You can chain multiple middleware layers or use third-party packages like gorilla/mux for advanced routing.

3. Making HTTP Client Requests

The http.Get , http.Post , and related convenience functions make outbound requests easy.

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

body, _ := io.ReadAll(resp.Body)
fmt.Printf("Response: %s", body)

For more control (custom headers, timeouts, etc.), create a custom http.Client :

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

req, _ := http.NewRequest("GET", "https://api.example.com/data", nil)
req.Header.Set("Authorization", "Bearer token")

resp, err := client.Do(req)

Key points:

• Always close resp.Body with defer resp.Body.Close() .
• Set timeouts to avoid hanging requests.
• Reuse http.Client instances (they're safe for concurrent use).

4. Handling JSON Requests and Responses

Many APIs use JSON. Use json.Marshal and json.Unmarshal with net/http .

Sending JSON Response

 type User struct {
    Name string `json:"name"`
    Email string `json:"email"`
}

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

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

Parsing JSON from Request

 func createUserHandler(w http.ResponseWriter, r *http.Request) {
    var user User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        Return
    }

    // Process user...
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

• Always set the Content-Type header when returning JSON.
• Validate input and handle decoding errors gracefully.

5. Graceful Shutdown

Hard-shutting down a server can interrupt active requests. Use graceful shutdown with http.Server and context .

 srv := &http.Server{
    Addr: ":8080",
    Handler: mux,
}

// Run server in a goroutine
go func() {
    if err := srv.ListenAndServe(); err != http.ErrServerClosed {
        log.Fatalf("Server failed: %v", err)
    }
}()

// Wait for interrupt signal
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c

// Gracefully shut down
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
srv.Shutdown(ctx)

This ensures ongoing requests finish before the server exits.

6. Common Pitfalls and Best Practices

• Don't ignore errors : Always check errors from http.ListenAndServe , json.Decode , etc.
• Avoid global state : Prefer injecting dependencies instead of using global variables in handlers.
• Use context for request-scoped data : Pass values via r.Context() instead of custom structs.
• Limit request body size : Use http.MaxBytesReader to prevent abuse:

 r.Body = http.MaxBytesReader(w, r.Body, 1<<20) // 1 MB limit

• Validate and sanitize input : Never trust client data.

The net/http package gives you everything you need to build robust web services without external dependencies. While frameworks like Gin or Echo add convenience, mastering net/http first gives you deeper insight and better control.

Basically, stick to the standard library unless you need performance optimizations or advanced routing — and even then, you'll still be using net/http under the hood.

The above is the detailed content of A Guide to the Go Standard Library's net/http Package. For more information, please follow other related articles on the PHP Chinese website!