第四章：HTTP协议基础入门

HTTP（HyperText Transfer Protocol）是互联网应用最广泛的网络协议，理解它是每个开发者必备的基础技能。本文将带你从零开始掌握HTTP协议的核心概念、工作原理和实际应用。

1. HTTP协议概述

1.1 什么是HTTP

HTTP（超文本传输协议）是应用层协议，用于从WWW服务器传输超文本到本地浏览器的传输协议。它基于TCP/IP通信协议来传递数据，是现代Web技术的基础。

HTTP的核心特点：

无状态：每次请求都是独立的，服务器不保留客户端状态
简单快速：客户向服务器请求时，只需传送请求方法和路径
灵活：允许传输任意类型的数据对象
无连接：限制每次连接只处理一个请求

1.2 HTTP在网络体系中的位置

HTTP工作在OSI七层模型的应用层，依赖传输层的TCP协议：

┌─────────────────────────┐
│    应用层 (Application)     │
│   HTTP、HTTPS、FTP...      │
├─────────────────────────┤
│    传输层 (Transport)      │
│       TCP、UDP           │
├─────────────────────────┤
│    网络层 (Network)        │
│       IP、ICMP           │
├─────────────────────────┤
│  网络接口层 (Network)      │
│     以太网、Wi-Fi...       │
└─────────────────────────┘

1.3 HTTP发展历史

HTTP/0.9 (1991年)

只有一个GET方法
不支持请求头
只能传输HTML格式的文本

HTTP/1.0 (1996年)

新增方法：GET、POST、HEAD
支持请求头和响应头
完整的HTTP状态码体系

HTTP/1.1 (1997年)

持久连接：Connection: keep-alive
管线化：支持多请求并发发送
新方法：PUT、DELETE、OPTIONS、TRACE、PATCH
支持虚拟主机（Host头）

HTTP/2 (2015年)

二进制分帧：使用二进制格式替代文本
多路复用：单连接处理多请求
头部压缩：减少传输开销
服务器推送：主动推送资源

HTTP/3 (2022年)

基于UDP的QUIC协议
0-RTT连接：快速建立连接
更好的拥塞控制

2. HTTP消息格式

2.1 请求消息结构

HTTP请求消息由三个部分组成：

[请求行] 方法 资源路径 协议版本
[请求头] Host: www.example.com
         User-Agent: Mozilla/5.0
         Accept: text/html
[空行]
[请求体] (可选)

请求行示例：

GET /api/users?page=1&limit=10 HTTP/1.1

完整请求示例：

GET /api/users?page=1&limit=10 HTTP/1.1
Host: api.example.com
User-Agent: MyApp/1.0
Accept: application/json
Authorization: Bearer token123

2.2 响应消息结构

HTTP响应消息同样由三个部分组成：

[状态行] 协议版本 状态码 状态描述
[响应头] Content-Type: application/json
         Content-Length: 1024
         Cache-Control: no-cache
[空行]
[响应体] (实际数据)

响应示例：

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 156
Cache-Control: no-cache

{
  "status": "success",
  "data": {
    "users": [...],
    "total": 100
  }
}

2.3 统一资源标识符（URI）

URI用于唯一标识Web上的资源：

https://www.example.com:8080/path/to/resource?param1=value1&param2=value2#fragment
│      │     │        │    │      │                    │        │
协议    域名   端口   路径   路径参数         查询参数       片段

3. HTTP方法详解

3.1 方法分类

安全方法（不修改服务器状态）：

GET：请求获取资源
HEAD：请求获取资源头信息
OPTIONS：请求获取支持的HTTP方法

幂等方法（多次执行结果相同）：

GET、HEAD、PUT、DELETE、OPTIONS、TRACE

常用方法：

POST：向服务器提交数据
PATCH：部分更新资源

3.2 GET方法

功能： 请求获取指定资源的表示

特点：

安全、幂等
参数通过URL传递
有长度限制
可以被缓存

示例：

GET /api/users?page=1&limit=10 HTTP/1.1
Host: api.example.com
Accept: application/json

3.3 POST方法

功能： 向服务器提交数据

特点：

不安全、不幂等
参数通过请求体传递
无长度限制
不被缓存

示例：

POST /api/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 85

{
  "name": "张三",
  "email": "zhangsan@example.com",
  "age": 25
}

3.4 PUT方法

功能： 完全替换指定资源

特点：

不安全但幂等
完整替换现有资源
支持大文件传输

使用场景：

完整更新资源
文件上传
配置更新

3.5 DELETE方法

功能： 删除指定资源

特点：

不安全但幂等
语义明确

示例：

DELETE /api/users/123 HTTP/1.1
Host: api.example.com

3.6 其他方法

HEAD： 获取资源头信息（与GET类似但不返回响应体）

OPTIONS： 获取服务器支持的HTTP方法

PATCH： 部分更新指定资源

TRACE： 回显服务器收到的请求（用于调试）

4. HTTP状态码详解

4.1 状态码分类

HTTP状态码分为5大类：

1xx（信息性）：请求正在处理
2xx（成功）：请求成功处理
3xx（重定向）：需要进一步操作
4xx（客户端错误）：请求有错误
5xx（服务器错误）：服务器处理出错

4.2 2xx成功状态码

200 OK

含义： 请求成功，服务器正常返回请求的数据

使用场景：

GET请求成功
POST请求创建成功
PUT/PATCH更新成功

201 Created

含义： 请求成功并且服务器创建了新的资源

特点：

通常用于POST请求创建资源
响应头Location包含新资源的URL

204 No Content

含义： 请求成功，但响应不包含实体内容

使用场景：

DELETE请求成功
PUT/PATCH更新成功但无需返回内容

4.3 3xx重定向状态码

301 Moved Permanently

含义： 资源已永久移动到新位置

使用场景：

域名迁移
URL结构改变

302 Found

含义： 资源临时移动到新位置

使用场景：

临时维护页面
负载均衡

304 Not Modified

含义： 资源未修改，使用缓存

使用场景：

浏览器缓存验证
CDN缓存

4.4 4xx客户端错误状态码

400 Bad Request

含义： 服务器无法理解请求

原因：

语法错误
无效参数
格式错误

401 Unauthorized

含义： 需要身份认证

特点：

需要用户提供身份凭证
响应头包含WWW-Authenticate

403 Forbidden

含义： 服务器理解请求但拒绝执行

原因：

权限不足
访问被禁止

404 Not Found

含义： 请求的资源不存在

原因：

URL错误
资源已删除

422 Unprocessable Entity

含义： 请求格式正确但语义错误

使用场景：

数据验证失败
业务逻辑错误

429 Too Many Requests

含义： 请求频率过高

特点：

响应头Retry-After包含重试时间
用于限流

4.5 5xx服务器错误状态码

500 Internal Server Error

含义： 服务器内部错误

原因：

代码异常
资源不足
配置错误

502 Bad Gateway

含义： 网关错误

原因：

上游服务器返回无效响应
网关配置错误

503 Service Unavailable

含义： 服务暂时不可用

特点：

响应头Retry-After包含恢复时间
临时状态

504 Gateway Timeout

含义： 网关超时

原因：

上游服务器响应超时
网络延迟

5. HTTP头部详解

5.1 通用头部字段

Cache-Control： 缓存控制指令

Cache-Control: public, max-age=3600
Cache-Control: no-cache
Cache-Control: no-store

Connection： 连接控制

Connection: keep-alive
Connection: close

Date： 消息创建的日期和时间

Date: Wed, 21 Oct 2023 07:28:00 GMT

5.2 请求头部字段

Host： 请求的主机名（HTTP/1.1必需）

Host: www.example.com

User-Agent： 用户代理字符串

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36

Accept： 可接受的响应内容类型

Accept: application/json
Accept: text/html,application/xhtml+xml

Authorization： 认证信息

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

Content-Type： 请求体内容类型

Content-Type: application/json
Content-Type: multipart/form-data

5.3 响应头部字段

Content-Type： 响应体内容类型

Content-Type: text/html; charset=utf-8
Content-Type: application/json

Content-Length： 响应体长度

Content-Length: 1024

ETag： 实体标识符

ETag: "abc123"
ETag: W/"abc123"

Last-Modified： 最后修改时间

Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

Location： 重定向目标URL

Location: https://www.example.com/new-page

6. HTTP缓存机制

6.1 缓存概述

HTTP缓存是提高Web性能的重要机制，通过在客户端或中间节点存储响应数据，避免重复请求相同资源。

缓存工作流程：

客户端请求 → 检查缓存 → 有缓存？ → 缓存有效？
                ↓           ↓        ↓
                ↓          否       是
                ↓           ↓        ↓
                ↓        转发到服务器  返回缓存
                ↓           ↓        ↓
                ↓        缓存响应    验证缓存

6.2 强缓存

强缓存直接使用缓存，不与服务器通信：

相关头信息：

Cache-Control: max-age=3600（缓存1小时）
Expires: Wed, 21 Oct 2023 07:28:00 GMT

配置示例：

http

# 静态资源缓存一年
Cache-Control: public, max-age=31536000

# HTML页面缓存5分钟
Cache-Control: public, max-age=300

6.3 协商缓存

协商缓存需要与服务器验证缓存有效性：

相关头信息：

ETag / If-None-Match：基于实体标签验证
Last-Modified / If-Modified-Since：基于时间验证

工作流程：

客户端请求资源
服务器检查缓存标识
返回304（使用缓存）或新资源

6.4 缓存策略

静态资源（CSS、JS、图片）：

http

Cache-Control: public, max-age=31536000
ETag: "static_v1.0"

动态页面：

http

Cache-Control: private, max-age=0, must-revalidate
ETag: "dynamic_abc123"

API数据：

http

Cache-Control: private, max-age=300
ETag: "api_v2"

6.5 缓存失效策略

版本化文件名：

/css/style.v1.0.css
/js/app.v1.0.js
/img/logo.v1.0.png

查询参数：

/api/users?cache=abc123
/api/users?ts=1686814200000

7. Go语言HTTP编程实践

7.1 HTTP客户端

基础GET请求

package main

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

func main() {
    // 创建HTTP客户端
    client := &http.Client{
        Timeout: 30 * time.Second,
    }

    // 发起GET请求
    resp, err := client.Get("https://httpbin.org/get")
    if err != nil {
        log.Fatal("请求失败:", err)
    }
    defer resp.Body.Close()

    // 读取响应
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatal("读取响应失败:", err)
    }

    fmt.Printf("状态码: %d\n", resp.StatusCode)
    fmt.Printf("响应内容:\n%s\n", string(body))
}

自定义请求头

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "time"
)

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

func main() {
    client := &http.Client{
        Timeout: 30 * time.Second,
    }

    // 创建用户数据
    user := User{
        Name:  "张三",
        Email: "zhangsan@example.com",
        Age:   25,
    }

    // 序列化为JSON
    jsonData, err := json.Marshal(user)
    if err != nil {
        log.Fatal("JSON序列化失败:", err)
    }

    // 创建POST请求
    req, err := http.NewRequest("POST", "https://httpbin.org/post",
        bytes.NewBuffer(jsonData))
    if err != nil {
        log.Fatal("创建请求失败:", err)
    }

    // 设置请求头
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("User-Agent", "MyApp/1.0")
    req.Header.Set("Authorization", "Bearer token123")

    // 发起请求
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal("请求失败:", err)
    }
    defer resp.Body.Close()

    // 读取响应
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatal("读取响应失败:", err)
    }

    fmt.Printf("状态码: %d\n", resp.StatusCode)
    fmt.Printf("响应内容:\n%s\n", string(body))
}

7.2 HTTP服务器

简单HTTP服务器

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"
)

// 用户数据模型
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// 用户数据存储（模拟数据库）
var users = []User{
    {ID: 1, Name: "张三", Age: 25},
    {ID: 2, Name: "李四", Age: 30},
}

// JSON响应工具
func writeJSONResponse(w http.ResponseWriter, statusCode int, data interface{}) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(statusCode)
    json.NewEncoder(w).Encode(data)
}

// 获取所有用户
func getUsersHandler(w http.ResponseWriter, r *http.Request) {
    writeJSONResponse(w, http.StatusOK, map[string]interface{}{
        "status": "success",
        "data":   users,
        "count":  len(users),
    })
}

// 获取单个用户
func getUserHandler(w http.ResponseWriter, r *http.Request) {
    // 简化处理，实际应解析路径参数
    if len(users) > 0 {
        writeJSONResponse(w, http.StatusOK, map[string]interface{}{
            "status": "success",
            "data":   users[0],
        })
    } else {
        writeJSONResponse(w, http.StatusNotFound, map[string]string{
            "status": "error",
            "message": "用户不存在",
        })
    }
}

// 创建用户
func createUserHandler(w http.ResponseWriter, r *http.Request) {
    var user User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        writeJSONResponse(w, http.StatusBadRequest, map[string]string{
            "status": "error",
            "message": "无效的JSON数据",
        })
        return
    }

    // 添加ID（实际应用中应由数据库生成）
    user.ID = len(users) + 1
    users = append(users, user)

    writeJSONResponse(w, http.StatusCreated, map[string]interface{}{
        "status": "success",
        "data":   user,
        "message": "用户创建成功",
    })
}

// 主函数
func main() {
    // 创建路由器
    mux := http.NewServeMux()

    // API路由
    mux.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
            getUsersHandler(w, r)
        case http.MethodPost:
            createUserHandler(w, r)
        default:
            writeJSONResponse(w, http.StatusMethodNotAllowed, map[string]string{
                "status":  "error",
                "message": "不支持的HTTP方法",
                "allowed": "GET, POST",
            })
        }
    })

    // 单个用户路由
    mux.HandleFunc("/api/users/", func(w http.ResponseWriter, r *http.Request) {
        if r.Method == http.MethodGet {
            getUserHandler(w, r)
        } else {
            writeJSONResponse(w, http.StatusMethodNotAllowed, map[string]string{
                "status":  "error",
                "message": "不支持的HTTP方法",
                "allowed": "GET",
            })
        }
    })

    // 健康检查
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        writeJSONResponse(w, http.StatusOK, map[string]interface{}{
            "status":    "healthy",
            "timestamp": time.Now(),
        })
    })

    // 创建服务器
    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
    }

    log.Printf("服务器启动，监听端口 :8080")
    log.Fatal(server.ListenAndServe())
}

中间件应用

package main

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

// 中间件函数类型
type Middleware func(http.HandlerFunc) http.HandlerFunc

// 日志中间件
func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next(w, r)
        duration := time.Since(start)
        log.Printf("%s %s %v", r.Method, r.URL.Path, duration)
    }
}

// CORS中间件
func corsMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

        // 处理预检请求
        if r.Method == http.MethodOptions {
            w.WriteHeader(http.StatusOK)
            return
        }

        next(w, r)
    }
}

// 应用中间件
func applyMiddleware(handler http.HandlerFunc, middlewares ...Middleware) http.HandlerFunc {
    for i := len(middlewares) - 1; i >= 0; i-- {
        handler = middlewares[i](handler)
    }
    return handler
}

func main() {
    mux := http.NewServeMux()

    // API路由（应用中间件）
    apiHandler := func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        response := map[string]interface{}{
            "message": "API请求成功",
            "time":    time.Now().Format("2006-01-02 15:04:05"),
            "method":  r.Method,
            "path":    r.URL.Path,
        }

        fmt.Fprintf(w, `{"message":"%s","time":"%s","method":"%s","path":"%s"}`,
            response["message"], response["time"],
            response["method"], response["path"])
    }

    // 应用多个中间件
    wrappedHandler := applyMiddleware(
        apiHandler,
        loggingMiddleware,
        corsMiddleware,
    )

    mux.HandleFunc("/api/", wrappedHandler)

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

    log.Printf("服务器启动，监听端口 :8080")
    log.Fatal(server.ListenAndServe())
}

7.3 错误处理和重试

package main

import (
    "fmt"
    "log"
    "math"
    "math/rand"
    "net/http"
    "time"
)

// 重试策略
type RetryConfig struct {
    MaxRetries    int
    InitialDelay  time.Duration
    BackoffFactor float64
}

var DefaultRetryConfig = RetryConfig{
    MaxRetries:    3,
    InitialDelay:  time.Second,
    BackoffFactor: 2.0,
}

// 重试HTTP请求
func RetryHTTPRequest(client *http.Client, req *http.Request, config RetryConfig) (*http.Response, error) {
    var lastErr error

    for attempt := 0; attempt <= config.MaxRetries; attempt++ {
        resp, err := client.Do(req)

        if err == nil {
            // 检查状态码是否需要重试
            if isRetryableStatusCode(resp.StatusCode) {
                resp.Body.Close()

                if attempt < config.MaxRetries {
                    delay := calculateDelay(attempt, config)
                    fmt.Printf("请求失败，状态码: %d，%v后重试...\n",
                        resp.StatusCode, delay)
                    time.Sleep(delay)
                    continue
                }
            }
            return resp, nil
        }

        lastErr = err

        if attempt < config.MaxRetries {
            delay := calculateDelay(attempt, config)
            fmt.Printf("请求错误: %v，%v后重试...\n", err, delay)
            time.Sleep(delay)
        }
    }

    return nil, fmt.Errorf("达到最大重试次数，最后一次错误: %v", lastErr)
}

// 检查状态码是否需要重试
func isRetryableStatusCode(statusCode int) bool {
    // 5xx服务器错误和429
    return statusCode >= 500 || statusCode == 429
}

// 计算重试延迟时间（指数退避 + 随机抖动）
func calculateDelay(attempt int, config RetryConfig) time.Duration {
    delay := float64(config.InitialDelay) *
        math.Pow(config.BackoffFactor, float64(attempt))

    // 添加随机抖动（±25%）
    jitter := delay * 0.25 * (2*rand.Float64() - 1)
    delay += jitter

    return time.Duration(delay)
}

func main() {
    client := &http.Client{
        Timeout: 60 * time.Second,
    }

    // 测试重试机制
    req, err := http.NewRequest("GET", "https://httpbin.org/status/500", nil)
    if err != nil {
        log.Fatal("创建请求失败:", err)
    }

    resp, err := RetryHTTPRequest(client, req, DefaultRetryConfig)
    if err != nil {
        fmt.Printf("重试失败: %v\n", err)
        return
    }

    fmt.Printf("最终状态码: %d\n", resp.StatusCode)
    resp.Body.Close()
}

8. HTTP性能优化

8.1 连接池配置

package main

import (
    "net/http"
    "time"
)

// 创建优化的HTTP客户端
func createOptimizedClient() *http.Client {
    transport := &http.Transport{
        // 连接池配置
        MaxIdleConns:        100,              // 最大空闲连接数
        MaxIdleConnsPerHost: 10,               // 每个主机的最大空闲连接数
        IdleConnTimeout:     90 * time.Second, // 空闲连接超时

        // 连接超时配置
        DialTimeout:         10 * time.Second,        // 建立连接超时
        TLSHandshakeTimeout: 10 * time.Second,       // TLS握手超时
        ResponseHeaderTimeout: 30 * time.Second,     // 响应头超时
    }

    return &http.Client{
        Transport: transport,
        Timeout:   60 * time.Second, // 整体请求超时
    }
}

8.2 压缩传输

package main

import (
    "compress/gzip"
    "fmt"
    "io"
    "log"
    "net/http"
    "strings"
)

// gzip压缩中间件
func gzipMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 检查客户端是否支持gzip
        if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
            next(w, r)
            return
        }

        // 设置响应头
        w.Header().Set("Content-Encoding", "gzip")

        // 创建gzip写入器
        gz := gzip.NewWriter(w)
        defer gz.Close()

        // 包装响应写入器
        gzw := &gzipResponseWriter{
            Writer:         gz,
            ResponseWriter: w,
        }

        next(gzw, r)
    }
}

type gzipResponseWriter struct {
    io.Writer
    http.ResponseWriter
}

func (w *gzipResponseWriter) Write(b []byte) (int, error) {
    return w.Writer.Write(b)
}

func main() {
    mux := http.NewServeMux()

    // 大数据响应处理
    largeDataHandler := func(w http.ResponseWriter, r *http.Request) {
        // 模拟大量数据
        data := make([]byte, 1024*1024) // 1MB数据
        for i := range data {
            data[i] = byte(i % 256)
        }

        w.Header().Set("Content-Type", "application/octet-stream")
        w.Header().Set("Content-Length", fmt.Sprintf("%d", len(data)))

        _, err := w.Write(data)
        if err != nil {
            log.Printf("写入数据失败: %v\n", err)
        }
    }

    // 应用gzip压缩
    wrappedHandler := gzipMiddleware(largeDataHandler)
    mux.HandleFunc("/large-data", wrappedHandler)

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

    log.Fatal(server.ListenAndServe())
}

9. 实际应用场景

9.1 RESTful API设计

package main

import (
    "encoding/json"
    "net/http"
    "strconv"
)

// RESTful路由示例
func setupRoutes() http.Handler {
    mux := http.NewServeMux()

    // 资源集合
    mux.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
            // 获取用户列表
            handleGetUsers(w, r)
        case http.MethodPost:
            // 创建用户
            handleCreateUser(w, r)
        default:
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        }
    })

    // 单个资源
    mux.HandleFunc("/api/users/", func(w http.ResponseWriter, r *http.Request) {
        userID, err := strconv.Atoi(r.URL.Path[len("/api/users/"):])
        if err != nil {
            http.Error(w, "Invalid user ID", http.StatusBadRequest)
            return
        }

        switch r.Method {
        case http.MethodGet:
            // 获取单个用户
            handleGetUser(w, r, userID)
        case http.MethodPut:
            // 更新用户
            handleUpdateUser(w, r, userID)
        case http.MethodDelete:
            // 删除用户
            handleDeleteUser(w, r, userID)
        default:
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        }
    })

    return mux
}

// 处理函数示例
func handleGetUsers(w http.ResponseWriter, r *http.Request) {
    // 获取查询参数
    page := r.URL.Query().Get("page")
    limit := r.URL.Query().Get("limit")

    response := map[string]interface{}{
        "status": "success",
        "data":   []User{}, // 实际从数据库获取
        "pagination": map[string]string{
            "page":  page,
            "limit": limit,
        },
    }

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

func handleCreateUser(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
    }

    // 验证和保存用户...

    w.Header().Set("Location", "/api/users/123")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

9.2 微服务通信

package main

import (
    "context"
    "encoding/json"
    "log"
    "net/http"
    "time"
)

// HTTP客户端包装器
type HTTPClient struct {
    client  *http.Client
    timeout time.Duration
}

func NewHTTPClient(timeout time.Duration) *HTTPClient {
    return &HTTPClient{
        client: &http.Client{
            Timeout: timeout,
            Transport: &http.Transport{
                MaxIdleConns:        100,
                MaxIdleConnsPerHost: 10,
                IdleConnTimeout:     90 * time.Second,
            },
        },
        timeout: timeout,
    }
}

// 带超时的请求
func (c *HTTPClient) DoWithTimeout(ctx context.Context, req *http.Request) (*http.Response, error) {
    // 设置超时
    ctx, cancel := context.WithTimeout(ctx, c.timeout)
    defer cancel()

    req = req.WithContext(ctx)
    return c.client.Do(req)
}

// 服务发现
type ServiceDiscovery struct {
    services map[string][]string // serviceName -> addresses
}

func NewServiceDiscovery() *ServiceDiscovery {
    return &ServiceDiscovery{
        services: make(map[string][]string),
    }
}

func (sd *ServiceDiscovery) Register(serviceName string, address string) {
    sd.services[serviceName] = append(sd.services[serviceName], address)
}

func (sd *ServiceDiscovery) GetService(serviceName string) (string, bool) {
    addresses, exists := sd.services[serviceName]
    if !exists || len(addresses) == 0 {
        return "", false
    }

    // 简单负载均衡：轮询
    // 实际应用中应使用更复杂的策略
    // 这里简化处理
    return addresses[0], true
}

// 微服务调用示例
func callUserService(sd *ServiceDiscovery, userID int) (*User, error) {
    address, exists := sd.GetService("user-service")
    if !exists {
        return nil, fmt.Errorf("user service not found")
    }

    url := fmt.Sprintf("http://%s/api/users/%d", address, userID)

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }

    client := NewHTTPClient(5 * time.Second)
    resp, err := client.DoWithTimeout(context.Background(), req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("user service returned status %d", resp.StatusCode)
    }

    var response struct {
        Data User `json:"data"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
        return nil, err
    }

    return &response.Data, nil
}

func main() {
    // 设置服务发现
    sd := NewServiceDiscovery()
    sd.Register("user-service", "user-service:8080")

    // 调用其他服务
    user, err := callUserService(sd, 123)
    if err != nil {
        log.Printf("调用用户服务失败: %v\n", err)
        return
    }

    log.Printf("获取到用户: %+v\n", user)
}

10. 最佳实践总结

10.1 客户端最佳实践

连接复用：使用连接池避免频繁建立连接
超时设置：合理设置连接、读取、整体超时时间
重试机制：对可重试的错误实施指数退避重试
请求去重：避免重复请求相同资源
压缩传输：启用gzip压缩减少传输量

10.2 服务器最佳实践

合理路由：设计清晰的RESTful API路由
中间件应用：使用中间件处理日志、CORS、认证等
状态码使用：正确使用HTTP状态码表示处理结果
错误处理：统一的错误处理和响应格式
缓存策略：合理配置缓存提高性能

10.3 性能优化建议

缓存配置：
- 静态资源：长期缓存
- 动态内容：协商缓存
- API数据：适度缓存
压缩传输：
- 启用gzip压缩
- 合理配置压缩阈值
- 对图片使用适当格式
连接优化：
- 使用HTTP/2多路复用
- 配置合理的连接池参数
- 避免连接泄漏

10.4 安全考虑

HTTPS使用：生产环境必须使用HTTPS
认证授权：实施适当的身份认证机制
输入验证：严格验证所有输入数据
限流保护：防止API被滥用
敏感信息：避免在URL中传递敏感信息

11. 相关RFC文档和技术资源

11.1 官方RFC文档

RFC 2616：HTTP/1.1规范
RFC 7230：HTTP/1.1消息语法
RFC 7231：HTTP/1.1语义和内容
RFC 7234：HTTP缓存
RFC 7540：HTTP/2规范
RFC 9114：HTTP/3规范

11.2 权威技术资源

MDN Web文档：HTTP指南
W3C规范：HTTP工作草案
IETF标准：互联网标准组织

11.3 Go语言资源

Go官方文档：net/http包
Go Web编程：Go Web应用开发
Gin框架：高性能HTTP框架

11.4 实践工具

curl：命令行HTTP客户端
Postman：API开发和测试工具
Wireshark：网络协议分析器
Chrome DevTools：浏览器开发者工具

总结

HTTP协议作为现代Web技术的基础，深入理解其工作原理对每个开发者都至关重要。本文从HTTP协议概述开始，详细介绍了：

协议基础：HTTP的发展历史、在网络体系中的位置、消息格式
方法体系：各种HTTP方法的含义、使用场景和最佳实践
状态码系统：完整的HTTP状态码分类和应用场景
头部字段：常用请求头和响应头的含义和配置
缓存机制：强缓存和协商缓存的工作原理和优化策略
Go语言实践：客户端、服务器开发，中间件应用和性能优化
实际应用：RESTful API设计、微服务通信等实际场景
最佳实践：性能优化、安全考虑和工具推荐

掌握这些知识将帮助你：

设计更高效的Web API
排查网络相关问题
优化应用性能
构建可扩展的分布式系统

HTTP协议还在持续发展，HTTP/2和HTTP/3的普及带来了新的性能优化机会。建议持续关注协议发展动态，在实际项目中合理应用这些技术，构建更好的Web应用。

参考文献：

RFC 2616 - Hypertext Transfer Protocol -- HTTP/1.1
RFC 7230 - HTTP/1.1 Message Syntax and Routing
Go net/http Package Documentation
Mozilla Developer Network - HTTP
RFC 7540 - HTTP/2 Specification
RFC 9114 - HTTP/3 Specification

第四章：HTTP协议基础入门 ​

1. HTTP协议概述 ​

1.1 什么是HTTP ​

1.2 HTTP在网络体系中的位置 ​

1.3 HTTP发展历史 ​

HTTP/0.9 (1991年) ​

HTTP/1.0 (1996年) ​

HTTP/1.1 (1997年) ​

HTTP/2 (2015年) ​

HTTP/3 (2022年) ​

2. HTTP消息格式 ​

2.1 请求消息结构 ​

2.2 响应消息结构 ​

2.3 统一资源标识符（URI） ​

3. HTTP方法详解 ​

3.1 方法分类 ​

3.2 GET方法 ​

3.3 POST方法 ​

3.4 PUT方法 ​

3.5 DELETE方法 ​

3.6 其他方法 ​

4. HTTP状态码详解 ​

4.1 状态码分类 ​

4.2 2xx成功状态码 ​

200 OK ​

201 Created ​

204 No Content ​

4.3 3xx重定向状态码 ​

301 Moved Permanently ​

302 Found ​

304 Not Modified ​

4.4 4xx客户端错误状态码 ​

400 Bad Request ​

401 Unauthorized ​

403 Forbidden ​

404 Not Found ​

422 Unprocessable Entity ​

429 Too Many Requests ​

4.5 5xx服务器错误状态码 ​

500 Internal Server Error ​

502 Bad Gateway ​

503 Service Unavailable ​

504 Gateway Timeout ​

5. HTTP头部详解 ​

5.1 通用头部字段 ​

5.2 请求头部字段 ​

5.3 响应头部字段 ​

6. HTTP缓存机制 ​

6.1 缓存概述 ​

6.2 强缓存 ​

6.3 协商缓存 ​

6.4 缓存策略 ​

6.5 缓存失效策略 ​

7. Go语言HTTP编程实践 ​

7.1 HTTP客户端 ​

基础GET请求 ​

自定义请求头 ​

7.2 HTTP服务器 ​

简单HTTP服务器 ​

中间件应用 ​

7.3 错误处理和重试 ​

8. HTTP性能优化 ​

8.1 连接池配置 ​

8.2 压缩传输 ​

9. 实际应用场景 ​

9.1 RESTful API设计 ​

9.2 微服务通信 ​

10. 最佳实践总结 ​

10.1 客户端最佳实践 ​

10.2 服务器最佳实践 ​

10.3 性能优化建议 ​

10.4 安全考虑 ​

11. 相关RFC文档和技术资源 ​

11.1 官方RFC文档 ​

11.2 权威技术资源 ​

11.3 Go语言资源 ​

11.4 实践工具 ​

总结 ​

第四章：HTTP协议基础入门

1. HTTP协议概述

1.1 什么是HTTP

1.2 HTTP在网络体系中的位置

1.3 HTTP发展历史

HTTP/0.9 (1991年)

HTTP/1.0 (1996年)

HTTP/1.1 (1997年)

HTTP/2 (2015年)

HTTP/3 (2022年)

2. HTTP消息格式

2.1 请求消息结构

2.2 响应消息结构

2.3 统一资源标识符（URI）

3. HTTP方法详解

3.1 方法分类

3.2 GET方法

3.3 POST方法

3.4 PUT方法

3.5 DELETE方法

3.6 其他方法

4. HTTP状态码详解

4.1 状态码分类

4.2 2xx成功状态码

200 OK

201 Created

204 No Content

4.3 3xx重定向状态码

301 Moved Permanently

302 Found

304 Not Modified

4.4 4xx客户端错误状态码

400 Bad Request

401 Unauthorized

403 Forbidden

404 Not Found

422 Unprocessable Entity

429 Too Many Requests

4.5 5xx服务器错误状态码

500 Internal Server Error

502 Bad Gateway

503 Service Unavailable

504 Gateway Timeout

5. HTTP头部详解

5.1 通用头部字段

5.2 请求头部字段

5.3 响应头部字段

6. HTTP缓存机制

6.1 缓存概述

6.2 强缓存

6.3 协商缓存

6.4 缓存策略

6.5 缓存失效策略

7. Go语言HTTP编程实践

7.1 HTTP客户端

基础GET请求

自定义请求头

7.2 HTTP服务器

简单HTTP服务器

中间件应用

7.3 错误处理和重试

8. HTTP性能优化

8.1 连接池配置

8.2 压缩传输

9. 实际应用场景

9.1 RESTful API设计

9.2 微服务通信

10. 最佳实践总结

10.1 客户端最佳实践

10.2 服务器最佳实践

10.3 性能优化建议

10.4 安全考虑

11. 相关RFC文档和技术资源

11.1 官方RFC文档

11.2 权威技术资源

11.3 Go语言资源

11.4 实践工具

总结