Go語言net/http庫使用詳解

更新時間：2025年10月11日 10:29:09 作者：n8n

net/http是Go語言標準庫中用于處理HTTP協(xié)議的核心組件,它提供了完整HTTP客戶端和服務(wù)器實現(xiàn),這個包讓開發(fā)者能夠快速構(gòu)建高性能的Web服務(wù),無需依賴第三方框架,感興趣的可以了解一下

1 概述

net/http是Go語言標準庫中用于處理HTTP協(xié)議的核心組件，它提供了完整HTTP客戶端和服務(wù)器實現(xiàn)。這個包讓開發(fā)者能夠快速構(gòu)建高性能的Web服務(wù)，無需依賴第三方框架。

1.1 主要特性

內(nèi)置高性能HTTP服務(wù)器：直接支持并發(fā)請求處理
簡潔的API設(shè)計：易于上手和使用
完整的HTTP協(xié)議支持：支持HTTP/1.x和HTTP/2
強大的路由機制：靈活的路由匹配和處理
中間件支持：可擴展的中間件架構(gòu)

2 HTTP服務(wù)器開發(fā)

2.1 基本服務(wù)器搭建

以下是創(chuàng)建一個最簡單HTTP服務(wù)器的示例：

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 注冊處理函數(shù)
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
    })
    
    // 啟動服務(wù)器
    fmt.Println("Starting server on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        fmt.Printf("Error starting server: %v\n", err)
    }
}

2.2 處理不同的HTTP方法

可以根據(jù)請求方法執(zhí)行不同的邏輯：

func handler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        fmt.Fprint(w, "This is a GET request.")
    case http.MethodPost:
        fmt.Fprint(w, "This is a POST request.")
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

2.3 請求參數(shù)處理

查詢參數(shù)（URL參數(shù)）

func queryHandler(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    age := r.URL.Query().Get("age")
    fmt.Fprintf(w, "Hello, %s! Age: %s", name, age)
}

表單數(shù)據(jù)

func formHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        err := r.ParseForm()
        if err != nil {
            http.Error(w, "Bad Request", http.StatusBadRequest)
            return
        }
        username := r.FormValue("username")
        password := r.FormValue("password")
        fmt.Fprintf(w, "Username: %s, Password: %s", username, password)
    }
}

JSON請求體

func jsonHandler(w http.ResponseWriter, r *http.Request) {
    type RequestData struct {
        Name  string `json:"name"`
        Email string `json:"email"`
    }
    
    var data RequestData
    err := json.NewDecoder(r.Body).Decode(&data)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    fmt.Fprintf(w, "Name: %s, Email: %s", data.Name, data.Email)
}

2.4 路由管理

使用ServeMux進行路由管理

func main() {
    mux := http.NewServeMux()
    
    mux.HandleFunc("/", homeHandler)
    mux.HandleFunc("/users", usersHandler)
    mux.HandleFunc("/posts", postsHandler)
    
    http.ListenAndServe(":8080", mux)
}

動態(tài)路由參數(shù)（需配合第三方路由庫）

雖然標準庫的ServeMux不支持動態(tài)路由參數(shù)，但可以結(jié)合正則表達式或使用第三方庫實現(xiàn)。

3 HTTP客戶端開發(fā)

3.1 發(fā)送GET請求

package main

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

func main() {
    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading body: %v\n", err)
        return
    }
    
    fmt.Println(string(body))
}

3.2 發(fā)送POST請求

func main() {
    data := []byte(`{"title": "foo", "body": "bar", "userId": 1}`)
    
    resp, err := http.Post(
        "https://jsonplaceholder.typicode.com/posts",
        "application/json",
        bytes.NewBuffer(data),
    )
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    // 處理響應(yīng)...
}

3.3 自定義請求

使用http.NewRequest可以創(chuàng)建更復雜的請求：

func main() {
    // 創(chuàng)建請求
    data := []byte(`{"name": "Go"}`)
    req, err := http.NewRequest("POST", "https://httpbin.org/post", bytes.NewBuffer(data))
    if err != nil {
        fmt.Printf("Error creating request: %v\n", err)
        return
    }
    
    // 設(shè)置請求頭
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer token123")
    
    // 發(fā)送請求
    client := &http.Client{
        Timeout: time.Second * 10,
    }
    
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error sending request: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    // 處理響應(yīng)...
}

3.4 客戶端超時設(shè)置

func main() {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }
    
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
}

4 高級特性

4.1 中間件開發(fā)

中間件可以在處理HTTP請求前后執(zhí)行特定邏輯：

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

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "valid-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
    })
    
    // 應(yīng)用中間件
    handler := loggingMiddleware(authMiddleware(mux))
    
    http.ListenAndServe(":8080", handler)
}

4.2 靜態(tài)文件服務(wù)

func main() {
    // 提供靜態(tài)文件服務(wù)
    fs := http.FileServer(http.Dir("static"))
    http.Handle("/static/", http.StripPrefix("/static/", fs))
    
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Main page")
    })
    
    http.ListenAndServe(":8080", nil)
}

4.3 Cookie處理

func cookieHandler(w http.ResponseWriter, r *http.Request) {
    // 讀取Cookie
    cookie, err := r.Cookie("session")
    if err != nil {
        // 創(chuàng)建新Cookie
        cookie = &http.Cookie{
            Name:     "session",
            Value:    "session-id-123",
            Path:     "/",
            HttpOnly: true,
        }
        http.SetCookie(w, cookie)
    }
    
    fmt.Fprintf(w, "Cookie value: %s", cookie.Value)
}

4.4 JSON響應(yīng)

func jsonResponseHandler(w http.ResponseWriter, r *http.Request) {
    type Response struct {
        Status  string `json:"status"`
        Message string `json:"message"`
        Data    interface{} `json:"data,omitempty"`
    }
    
    response := Response{
        Status:  "success",
        Message: "Data retrieved successfully",
        Data: map[string]interface{}{
            "id":   1,
            "name": "John Doe",
        },
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

5 常見問題與解決方案

5.1 易錯點及避免方法

易錯點	問題描述	解決方案
資源泄露	未關(guān)閉響應(yīng)體	總是使用`defer resp.Body.Close()`
路由沖突	路由匹配順序錯誤	明確路由優(yōu)先級，從具體到一般
阻塞操作	長時間運行的操作阻塞服務(wù)	使用goroutine處理耗時任務(wù)
內(nèi)存泄漏	不當使用全局變量或緩存	合理管理資源生命周期

5.2 性能優(yōu)化建議

連接復用：使用http.Client的默認連接池
超時設(shè)置：為客戶端和服務(wù)器設(shè)置合理的超時時間
并發(fā)處理：利用Go的并發(fā)特性處理請求
靜態(tài)資源緩存：合理設(shè)置緩存頭減少重復傳輸

5.3 安全最佳實踐

func secureHeadersMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 設(shè)置安全相關(guān)的HTTP頭
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("X-Frame-Options", "DENY")
        w.Header().Set("X-XSS-Protection", "1; mode=block")
        w.Header().Set("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
        
        next.ServeHTTP(w, r)
    })
}

6 實戰(zhàn)案例：完整的API服務(wù)

以下是一個完整的用戶管理API示例：

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "strconv"
    "time"
    
    "github.com/gorilla/mux"
)

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

var users = []User{
    {ID: 1, Name: "Alice", Email: "alice@example.com"},
    {ID: 2, Name: "Bob", Email: "bob@example.com"},
}

func getUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

func getUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    
    for _, user := range users {
        if user.ID == id {
            json.NewEncoder(w).Encode(user)
            return
        }
    }
    
    http.Error(w, "User not found", http.StatusNotFound)
}

func createUser(w http.ResponseWriter, r *http.Request) {
    var user User
    err := json.NewDecoder(r.Body).Decode(&user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    user.ID = len(users) + 1
    users = append(users, user)
    
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

func loggingMiddleware(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 %v", r.Method, r.URL.Path, time.Since(start))
    })
}

func main() {
    router := mux.NewRouter()
    
    // 路由定義
    router.HandleFunc("/users", getUsers).Methods("GET")
    router.HandleFunc("/users/{id}", getUser).Methods("GET")
    router.HandleFunc("/users", createUser).Methods("POST")
    
    // 應(yīng)用中間件
    router.Use(loggingMiddleware)
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", router))
}