# 6.2 HTTP协议与Web服务器原理¶

核心目标¶

掌握HTTP协议细节，理解Web服务器与客户端的交互本质

1. HTTP协议基础¶

HTTP（HyperText Transfer Protocol，超文本传输协议）是用于在万维网（WWW）上传输数据的应用层协议。

协议作用¶

HTTP定义了客户端（如浏览器）与Web服务器之间如何通信，规定了请求和响应的格式、数据传输方式以及处理规则，是互联网信息交换的基础协议。

核心特点¶

无状态：服务器不会保留客户端的历史请求信息，每个请求都是独立的
应用层协议：工作在OSI模型的应用层，依赖下层的TCP协议提供可靠传输
基于请求-响应模型：客户端发送请求，服务器返回响应
媒体无关性：只要客户端和服务器知道如何处理数据格式，任何类型的数据都可以通过HTTP传输

协议版本演进¶

HTTP/1.1（1999年）
引入持久连接（Keep-Alive），允许在一个TCP连接上发送多个请求
支持管道化传输，允许客户端在收到前一个响应前发送多个请求
增加了缓存机制、Chunked编码传输等功能
HTTP/2.0（2015年）
采用二进制帧格式，取代了HTTP/1.x的文本格式
实现多路复用，多个请求可以在一个TCP连接上并行处理
引入服务器推送（Server Push）功能
头部压缩，减少传输开销
HTTP/3.0（2022年）
基于QUIC协议（快速UDP互联网连接），取代了TCP
解决了TCP队头阻塞问题
更快的连接建立（0-RTT或1-RTT握手）
内置加密和认证机制

2. 请求与响应结构¶

请求格式¶

HTTP请求由以下几个部分组成：

<方法> <URI> <版本>
<请求头部字段1>: <值1>
<请求头部字段2>: <值2>
...
空行
<实体主体>

示例：

GET /index.html HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Accept: text/html,application/xhtml+xml
Connection: keep-alive

(可选的请求体，GET请求通常没有)

响应格式¶

HTTP响应的结构如下：

<版本> <状态码> <状态描述>
<响应头部字段1>: <值1>
<响应头部字段2>: <值2>
...
空行
<实体主体>

示例：

HTTP/1.1 200 OK
Date: Fri, 19 Sep 2025 12:00:00 GMT
Server: Apache/2.4.41
Content-Type: text/html; charset=UTF-8
Content-Length: 1234

<html>
  <head><title>Example</title></head>
  <body><h1>Hello World</h1></body>
</html>

实战：用tcpdump抓取HTTP包¶

可以使用tcpdump工具抓取实际的HTTP流量，分析请求和响应内容：

# 抓取端口80的HTTP流量
sudo tcpdump -i any port 80 -A -s 0

# 抓取特定主机的HTTP流量
sudo tcpdump -i any host example.com and port 80 -A -s 0

参数说明： - -i any：监听所有网络接口 - port 80：只抓取80端口的流量（HTTP默认端口） - -A：以ASCII码形式显示数据包内容 - -s 0：捕获完整的数据包

用Go实现简单的HTTP请求分析器¶

下面是一个简单的Go程序，可以解析HTTP请求并输出其各个组成部分：

package main

import (
    "bufio"
    "fmt"
    "net"
    "strings"
)

func main() {
    // 监听本地8080端口
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Printf("无法监听端口: %v\n", err)
        return
    }
    defer listener.Close()

    fmt.Println("服务器启动，监听端口8080...")

    for {
        // 接受客户端连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Printf("接受连接失败: %v\n", err)
            continue
        }

        // 并发处理每个连接
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()

    reader := bufio.NewReader(conn)

    // 读取请求行
    requestLine, err := reader.ReadString('\n')
    if err != nil {
        fmt.Printf("读取请求行失败: %v\n", err)
        return
    }
    requestLine = strings.TrimSpace(requestLine)
    parts := strings.Split(requestLine, " ")
    if len(parts) != 3 {
        fmt.Println("无效的请求行")
        return
    }

    method, uri, version := parts[0], parts[1], parts[2]
    fmt.Printf("请求行: %s %s %s\n", method, uri, version)

    // 读取请求头部
    headers := make(map[string]string)
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            fmt.Printf("读取头部失败: %v\n", err)
            return
        }
        line = strings.TrimSpace(line)
        if line == "" { // 空行表示头部结束
            break
        }

        headerParts := strings.SplitN(line, ":", 2)
        if len(headerParts) == 2 {
            name := strings.TrimSpace(headerParts[0])
            value := strings.TrimSpace(headerParts[1])
            headers[name] = value
            fmt.Printf("头部: %s: %s\n", name, value)
        }
    }

    // 构建响应
    response := "HTTP/1.1 200 OK\r\n"
    response += "Content-Type: text/plain\r\n"
    response += "Connection: close\r\n"
    response += "\r\n"
    response += "请求已收到并解析"

    // 发送响应
    conn.Write([]byte(response))
}

运行程序后，你可以用浏览器访问http://localhost:8080，服务器会在控制台输出解析到的HTTP请求信息。

3. 核心概念详解¶

状态码¶

HTTP状态码由三位数字组成，用于表示请求的处理结果：

2xx（成功）
200 OK：请求成功
201 Created：资源创建成功
204 No Content：请求成功，但无返回内容
3xx（重定向）
301 Moved Permanently：资源永久移动到新位置
302 Found：资源临时移动到新位置
304 Not Modified：资源未修改，可使用缓存
4xx（客户端错误）
400 Bad Request：请求格式错误
401 Unauthorized：需要身份验证
403 Forbidden：服务器拒绝请求
404 Not Found：资源不存在
405 Method Not Allowed：请求方法不被允许
5xx（服务器错误）
500 Internal Server Error：服务器内部错误
502 Bad Gateway：网关错误
503 Service Unavailable：服务器暂时不可用
504 Gateway Timeout：网关超时

请求方法¶

HTTP定义了多种请求方法，每种方法有特定的语义：

GET：请求获取指定资源，不应有副作用，可缓存
POST：向服务器提交数据，可能导致新资源创建或状态变化
PUT：全量更新指定资源，若资源不存在则创建
PATCH：部分更新指定资源
DELETE：删除指定资源
HEAD：类似GET，但只返回头部，不返回实体主体
OPTIONS：获取服务器支持的HTTP方法
CONNECT：建立隧道，通常用于HTTPS
TRACE：回显服务器收到的请求，用于诊断

头部字段¶

HTTP头部用于传递额外的元数据：

Host：指定请求的服务器主机名和端口
Content-Type：指示实体主体的媒体类型（如text/html, application/json）
Accept：客户端可接受的响应内容类型
User-Agent：客户端标识信息（如浏览器类型和版本）
Cookie：客户端发送给服务器的Cookie信息
Set-Cookie：服务器发送给客户端的Cookie信息
Authorization：身份验证信息
Content-Length：实体主体的长度（字节数）
Cache-Control：缓存控制指令
Expires：资源过期时间
ETag：资源的实体标签，用于缓存验证
Location：用于重定向，指示新的资源位置

用Go实现状态码和请求方法处理¶

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 注册不同路径和方法的处理器
    http.HandleFunc("/", handleRoot)
    http.HandleFunc("/data", handleData)
    http.HandleFunc("/user", handleUser)

    fmt.Println("服务器启动，监听端口8080...")
    http.ListenAndServe(":8080", nil)
}

// 处理根路径
func handleRoot(w http.ResponseWriter, r *http.Request) {
    // 只允许GET方法
    if r.Method != http.MethodGet {
        http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
        return
    }

    fmt.Fprintf(w, "欢迎访问首页")
}

// 处理数据请求
func handleData(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        // 模拟获取数据
        w.Header().Set("Content-Type", "application/json")
        fmt.Fprintf(w, `{"id": 1, "name": "示例数据"}`)

    case http.MethodPost:
        // 模拟创建数据
        w.WriteHeader(http.StatusCreated)
        fmt.Fprintf(w, "数据创建成功")

    default:
        http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
    }
}

// 处理用户请求
func handleUser(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        // 模拟获取用户信息
        userID := r.URL.Query().Get("id")
        if userID == "" {
            http.Error(w, "缺少用户ID", http.StatusBadRequest)
            return
        }
        fmt.Fprintf(w, "用户信息: ID=%s", userID)

    case http.MethodPut:
        // 模拟更新用户
        w.WriteHeader(http.StatusOK)
        fmt.Fprintf(w, "用户更新成功")

    case http.MethodDelete:
        // 模拟删除用户
        w.WriteHeader(http.StatusNoContent)

    default:
        http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
    }
}

这个示例展示了如何在Go中处理不同的HTTP方法和返回适当的状态码。

4. 连接与缓存机制¶

持久连接（Keep-Alive）¶

HTTP/1.1默认使用持久连接，允许在一个TCP连接上发送多个HTTP请求和响应，避免了频繁建立和关闭连接的开销。

在HTTP/1.0中，需要显式指定Connection: keep-alive头部来启用持久连接。

持久连接的优势： - 减少TCP握手和挥手的开销 - 降低服务器的CPU和内存消耗 - 减少网络延迟，提升页面加载速度

缓存策略¶

HTTP缓存机制可以减少重复请求，降低服务器负载，提高响应速度：

Cache-Control：
max-age=<seconds>：资源在指定秒数内有效
public：响应可以被任何缓存存储
private：响应只能被单个用户的缓存存储
no-cache：需要验证资源是否新鲜才能使用缓存
no-store：不缓存任何响应内容
Expires：指定资源过期的绝对时间（HTTP/1.0）
优先级低于Cache-Control: max-age
验证机制：
ETag：资源的唯一标识，服务器生成
If-None-Match：客户端发送上次获取的ETag，服务器比较判断是否更新
Last-Modified：资源最后修改时间
If-Modified-Since：客户端发送上次获取的修改时间

实战：实现带缓存控制的静态资源服务器¶

package main

import (
    "log"
    "net/http"
    "os"
    "path/filepath"
    "time"
)

// 自定义文件服务器，添加缓存控制
type CachedFileServer struct {
    root http.FileSystem
}

func NewCachedFileServer(root string) *CachedFileServer {
    return &CachedFileServer{
        root: http.Dir(root),
    }
}

func (s *CachedFileServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 获取请求的文件路径
    path := r.URL.Path
    if path == "/" {
        path = "/index.html" // 默认首页
    }

    // 打开文件
    file, err := s.root.Open(path)
    if err != nil {
        http.Error(w, "文件未找到", http.StatusNotFound)
        return
    }
    defer file.Close()

    // 获取文件信息
    fileInfo, err := file.Stat()
    if err != nil {
        http.Error(w, "无法获取文件信息", http.StatusInternalServerError)
        return
    }

    // 根据文件类型设置Content-Type
    ext := filepath.Ext(path)
    switch ext {
    case ".html", ".htm":
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
    case ".css":
        w.Header().Set("Content-Type", "text/css")
    case ".js":
        w.Header().Set("Content-Type", "application/javascript")
    case ".png":
        w.Header().Set("Content-Type", "image/png")
    case ".jpg", ".jpeg":
        w.Header().Set("Content-Type", "image/jpeg")
    case ".gif":
        w.Header().Set("Content-Type", "image/gif")
    }

    // 设置缓存控制
    switch ext {
    case ".html", ".htm":
        // HTML文件缓存时间短，需要验证
        w.Header().Set("Cache-Control", "public, max-age=60, must-revalidate")
    case ".css", ".js":
        // 静态资源缓存时间长
        w.Header().Set("Cache-Control", "public, max-age=31536000")
    case ".png", ".jpg", ".jpeg", ".gif":
        // 图片缓存时间更长
        w.Header().Set("Cache-Control", "public, max-age=63072000")
    }

    // 设置ETag和Last-Modified
    etag := fmt.Sprintf("\"%x-%x\"", fileInfo.ModTime().Unix(), fileInfo.Size())
    w.Header().Set("ETag", etag)
    w.Header().Set("Last-Modified", fileInfo.ModTime().UTC().Format(http.TimeFormat))

    // 检查缓存是否有效
    if r.Header.Get("If-None-Match") == etag {
        w.WriteHeader(http.StatusNotModified)
        return
    }

    lastModified, err := time.Parse(http.TimeFormat, r.Header.Get("If-Modified-Since"))
    if err == nil && !fileInfo.ModTime().After(lastModified) {
        w.WriteHeader(http.StatusNotModified)
        return
    }

    // 设置内容长度
    w.Header().Set("Content-Length", fmt.Sprintf("%d", fileInfo.Size()))

    // 发送文件内容
    http.ServeContent(w, r, path, fileInfo.ModTime(), file)
}

func main() {
    // 获取当前目录作为静态文件根目录
    dir, err := os.Getwd()
    if err != nil {
        log.Fatalf("无法获取当前目录: %v", err)
    }

    // 创建带缓存控制的文件服务器
    fileServer := NewCachedFileServer(dir)

    // 注册处理函数
    http.Handle("/", fileServer)

    // 启动服务器
    log.Println("静态资源服务器启动，监听端口8080...")
    log.Printf("服务目录: %s\n", dir)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

这个服务器实现了以下缓存功能： 1. 根据文件类型设置不同的缓存策略 2. 生成ETag和Last-Modified头部 3. 处理If-None-Match和If-Modified-Since请求头部 4. 当资源未修改时返回304 Not Modified状态码

5. Cookie与Session¶

Cookie是服务器存储在客户端的小型数据片段，用于跟踪用户状态：

Cookie属性： - Name：Cookie名称 - Value：Cookie值 - Max-Age：存活时间（秒），负数表示会话结束时删除 - Expires：过期的绝对时间，与Max-Age类似但优先级低 - Domain：Cookie有效的域名 - Path：Cookie有效的路径 - HttpOnly：限制Cookie只能通过HTTP(S)传输，不能被JavaScript访问 - Secure：仅在HTTPS连接中传输 - SameSite：控制跨站请求时Cookie的发送策略（Strict, Lax, None）

Session¶

Session是服务器端存储的用户会话信息，通常通过Cookie中的会话ID关联：

Session存储方式： 1. 内存存储：简单但不适合分布式系统，服务器重启后丢失 2. 文件存储：将Session数据保存到文件 3. 数据库存储：如MySQL、PostgreSQL等关系型数据库 4. 缓存存储：如Redis、Memcached等，性能好，适合高并发

安全问题¶

Cookie劫持：攻击者窃取Cookie后伪装成合法用户
防御措施：
使用HttpOnly属性防止JavaScript访问
使用Secure属性确保仅通过HTTPS传输
使用SameSite属性限制跨站请求
定期轮换Session ID
对敏感操作进行二次验证
设置合理的Cookie过期时间

用Go实现Cookie与Session管理¶

package main

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "net/http"
    "sync"
    "time"
)

// Session数据结构
type Session struct {
    ID        string
    Data      map[string]interface{}
    ExpiresAt time.Time
}

// Session管理器
type SessionManager struct {
    sessions map[string]*Session
    mu       sync.RWMutex
    expiry   time.Duration
}

// 创建新的Session管理器
func NewSessionManager(expiry time.Duration) *SessionManager {
    manager := &SessionManager{
        sessions: make(map[string]*Session),
        expiry:   expiry,
    }

    // 启动定期清理过期Session的goroutine
    go manager.cleanupExpiredSessions()

    return manager
}

// 生成随机Session ID
func generateSessionID() string {
    b := make([]byte, 32)
    _, err := rand.Read(b)
    if err != nil {
        panic(err)
    }
    return base64.URLEncoding.EncodeToString(b)
}

// 创建新Session
func (m *SessionManager) CreateSession() *Session {
    m.mu.Lock()
    defer m.mu.Unlock()

    sessionID := generateSessionID()
    session := &Session{
        ID:        sessionID,
        Data:      make(map[string]interface{}),
        ExpiresAt: time.Now().Add(m.expiry),
    }

    m.sessions[sessionID] = session
    return session
}

// 获取Session
func (m *SessionManager) GetSession(sessionID string) (*Session, bool) {
    m.mu.RLock()
    defer m.mu.RUnlock()

    session, exists := m.sessions[sessionID]
    if !exists {
        return nil, false
    }

    // 检查是否过期
    if time.Now().After(session.ExpiresAt) {
        return nil, false
    }

    // 延长Session有效期
    session.ExpiresAt = time.Now().Add(m.expiry)
    return session, true
}

// 删除Session
func (m *SessionManager) DeleteSession(sessionID string) {
    m.mu.Lock()
    defer m.mu.Unlock()
    delete(m.sessions, sessionID)
}

// 定期清理过期Session
func (m *SessionManager) cleanupExpiredSessions() {
    ticker := time.NewTicker(5 * time.Minute)
    defer ticker.Stop()

    for {
        <-ticker.C
        m.mu.Lock()

        now := time.Now()
        for id, session := range m.sessions {
            if now.After(session.ExpiresAt) {
                delete(m.sessions, id)
            }
        }

        m.mu.Unlock()
    }
}

var sessionManager = NewSessionManager(24 * time.Hour)

func main() {
    http.HandleFunc("/", indexHandler)
    http.HandleFunc("/login", loginHandler)
    http.HandleFunc("/logout", logoutHandler)
    http.HandleFunc("/profile", profileHandler)

    fmt.Println("服务器启动，监听端口8080...")
    http.ListenAndServe(":8080", nil)
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
    cookie, err := r.Cookie("session_id")
    var isLoggedIn bool

    if err == nil {
        if _, exists := sessionManager.GetSession(cookie.Value); exists {
            isLoggedIn = true
        }
    }

    w.Header().Set("Content-Type", "text/html; charset=utf-8")
    fmt.Fprintf(w, `
        <html>
        <head><title>首页</title></head>
        <body>
            <h1>欢迎访问首页</h1>
            %s
            <p><a href="/login">登录</a> | <a href="/profile">个人资料</a> | <a href="/logout">退出</a></p>
        </body>
        </html>
    `, map[bool]string{true: "<p>您已登录</p>", false: "<p>您未登录</p>"}[isLoggedIn])
}

func loginHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPost {
        username := r.FormValue("username")
        password := r.FormValue("password")

        // 简单验证，实际应用中应查询数据库
        if username == "admin" && password == "password" {
            // 创建新Session
            session := sessionManager.CreateSession()
            session.Data["username"] = username

            // 设置Session ID到Cookie
            http.SetCookie(w, &http.Cookie{
                Name:     "session_id",
                Value:    session.ID,
                HttpOnly: true,
                Secure:   false, // 生产环境应设为true（HTTPS）
                SameSite: http.SameSiteLaxMode,
                MaxAge:   86400, // 24小时
                Path:     "/",
            })

            http.Redirect(w, r, "/", http.StatusFound)
            return
        }

        fmt.Fprintf(w, "<p>用户名或密码错误</p>")
        return
    }

    // 显示登录表单
    w.Header().Set("Content-Type", "text/html; charset=utf-8")
    fmt.Fprintf(w, `
        <html>
        <head><title>登录</title></head>
        <body>
            <h1>登录</h1>
            <form method="post">
                <div>
                    <label>用户名: <input type="text" name="username"></label>
                </div>
                <div>
                    <label>密码: <input type="password" name="password"></label>
                </div>
                <div>
                    <button type="submit">登录</button>
                </div>
            </form>
        </body>
        </html>
    `)
}

func logoutHandler(w http.ResponseWriter, r *http.Request) {
    cookie, err := r.Cookie("session_id")
    if err == nil {
        // 删除服务器端Session
        sessionManager.DeleteSession(cookie.Value)

        // 设置Cookie过期
        http.SetCookie(w, &http.Cookie{
            Name:     "session_id",
            Value:    "",
            HttpOnly: true,
            MaxAge:   -1, // 立即过期
            Path:     "/",
        })
    }

    http.Redirect(w, r, "/", http.StatusFound)
}

func profileHandler(w http.ResponseWriter, r *http.Request) {
    cookie, err := r.Cookie("session_id")
    if err != nil {
        http.Redirect(w, r, "/login", http.StatusFound)
        return
    }

    session, exists := sessionManager.GetSession(cookie.Value)
    if !exists {
        http.Redirect(w, r, "/login", http.StatusFound)
        return
    }

    username, ok := session.Data["username"].(string)
    if !ok {
        http.Redirect(w, r, "/login", http.StatusFound)
        return
    }

    w.Header().Set("Content-Type", "text/html; charset=utf-8")
    fmt.Fprintf(w, `
        <html>
        <head><title>个人资料</title></head>
        <body>
            <h1>个人资料</h1>
            <p>用户名: %s</p>
            <p>Session ID: %s</p>
            <p>过期时间: %s</p>
            <p><a href="/">返回首页</a></p>
        </body>
        </html>
    `, username, session.ID, session.ExpiresAt.Format(time.RFC1123))
}

这个示例实现了完整的Cookie和Session管理功能： 1. 使用内存存储Session数据 2. 实现了Session的创建、获取和删除 3. 定期清理过期Session 4. 设置了安全的Cookie属性（HttpOnly, SameSite） 5. 提供了登录、注销和个人资料页面的完整流程

在实际生产环境中，你可能需要将Session存储在Redis等分布式缓存中，以支持多服务器部署。