6.1 net/http包深度解析¶

6.1 Go标准库`net/http`深度解析¶

核心目标¶

理解Go原生Web服务器的工作原理，掌握net/http包的核心组件与使用方法，能够独立开发高性能的Web服务。

1. 快速入门：Hello World Web服务¶

Go语言的net/http包提供了完整的HTTP客户端和服务器实现，让我们可以用极少的代码创建一个Web服务。

最小化Web服务实现¶

下面是一个仅用3行核心代码实现的Web服务：

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 注册处理器函数
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World! 你访问的路径是: %s", r.URL.Path)
    })

    // 启动HTTP服务器
    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

代码解析¶

http.HandleFunc(pattern string, handler func(ResponseWriter, *Request))
作用：将一个处理器函数注册到默认路由（DefaultServeMux）
参数说明：
- pattern：URL路径模式，这里使用"/"表示匹配所有路径
- handler：处理请求的函数，接收两个参数：
- http.ResponseWriter：用于构建响应
- *http.Request：包含客户端请求的所有信息
http.ListenAndServe(addr string, handler Handler)
作用：启动HTTP服务器并监听指定地址
参数说明：
- addr：监听地址，格式为"host:port"，":8080"表示监听所有网络接口的8080端口
- handler：指定根处理器，传nil表示使用默认的DefaultServeMux
该函数会阻塞运行，直到发生错误

运行与测试¶

保存代码为main.go，运行：
```
go run main.go
```

使用curl测试：

curl http://localhost:8080
curl http://localhost:8080/hello
curl http://localhost:8080/user/profile

也可以直接在浏览器中访问这些URL，观察返回结果的差异。

2. 核心组件：Handler接口与处理器¶

net/http包的核心设计围绕Handler接口展开，理解它是掌握Go Web编程的关键。

Handler接口定义¶

Handler接口是所有处理器的基础，定义非常简洁：

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

任何类型只要实现了ServeHTTP方法，就可以作为HTTP请求的处理器。

处理器函数：HandlerFunc类型的适配原理¶

Go提供了HandlerFunc类型，让普通函数可以轻松实现Handler接口：

// HandlerFunc的定义
type HandlerFunc func(ResponseWriter, *Request)

// 实现Handler接口的ServeHTTP方法
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r) // 调用函数本身
}

这种设计被称为"适配器模式"，让我们可以直接将普通函数用作处理器：

package main

import (
    "fmt"
    "net/http"
)

// 普通函数，符合HandlerFunc的签名
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello from handler function!")
}

func main() {
    // 注册处理器函数
    http.HandleFunc("/hello", helloHandler)

    // 启动服务器
    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

自定义处理器：结构体实现Handler接口¶

除了函数，我们也可以用结构体实现Handler接口，这在需要维护状态时特别有用：

package main

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

// 自定义处理器结构体
type TimeHandler struct {
    Format string // 时间格式
}

// 实现Handler接口的ServeHTTP方法
func (th *TimeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    currentTime := time.Now().Format(th.Format)
    fmt.Fprintf(w, "当前时间: %s", currentTime)
}

// 另一个自定义处理器
type GreetingHandler struct {
    Prefix string // 问候前缀
}

func (gh *GreetingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "Guest"
    }
    fmt.Fprintf(w, "%s, %s!", gh.Prefix, name)
}

func main() {
    // 注册自定义处理器
    http.Handle("/time", &TimeHandler{Format: time.RFC3339})
    http.Handle("/greet", &GreetingHandler{Prefix: "Hello"})

    // 启动服务器
    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

测试上述服务：

curl http://localhost:8080/time
curl http://localhost:8080/greet?name=Alice

3. 路由管理：`ServeMux`工作机制¶

ServeMux（服务多路复用器）是Go内置的路由管理器，负责将请求分发到对应的处理器。

ServeMux的功能¶

ServeMux主要完成两项工作： 1. 路由匹配：根据请求的URL路径找到对应的处理器 2. 请求分发：将请求转发给匹配到的处理器处理

路由规则与匹配优先级¶

ServeMux的路由匹配遵循以下规则：

静态路由优先于参数路由
更长的路径优先匹配
以/结尾的路径会匹配该路径下的所有子路径（如/user/匹配/user/profile）
没有/结尾的路径只精确匹配

示例：

package main

import (
    "fmt"
    "net/http"
)

func rootHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "这是根路径")
}

func userHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "这是用户列表页")
}

func userProfileHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "这是用户详情页")
}

func main() {
    // 注册不同的路由
    http.HandleFunc("/", rootHandler)
    http.HandleFunc("/user", userHandler)
    http.HandleFunc("/user/profile", userProfileHandler)

    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

测试不同URL的匹配结果： - http://localhost:8080 → 匹配/ - http://localhost:8080/user → 匹配/user - http://localhost:8080/user/profile → 匹配/user/profile - http://localhost:8080/user/other → 匹配/（因为没有更精确的匹配）

自定义ServeMux¶

除了使用默认的DefaultServeMux，我们也可以创建自定义的ServeMux：

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 创建自定义的ServeMux
    mux := http.NewServeMux()

    // 注册路由到自定义mux
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "使用自定义ServeMux")
    })

    mux.HandleFunc("/about", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "关于我们")
    })

    // 启动服务器时指定使用自定义mux
    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", mux)
}

使用自定义ServeMux的好处： - 避免全局状态（默认的DefaultServeMux是全局的） - 可以创建多个ServeMux，实现更复杂的路由策略 - 更好的封装性和测试性

4. 服务器配置：`Server`结构体详解¶

http.Server结构体提供了更精细的服务器配置选项，相比http.ListenAndServe的简单形式，它能满足生产环境的各种需求。

核心配置项¶

type Server struct {
    Addr           string        // 监听地址，格式为"host:port"
    Handler        Handler       // 根处理器，nil表示使用DefaultServeMux
    ReadTimeout    time.Duration // 读取请求的超时时间
    WriteTimeout   time.Duration // 写入响应的超时时间
    IdleTimeout    time.Duration // 连接空闲超时时间
    MaxHeaderBytes int           // 请求头的最大字节数
    // 其他配置项...
}

配置示例：

package main

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

func main() {
    // 创建处理器
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, Custom Server!")
    })

    // 配置服务器
    server := &http.Server{
        Addr:           ":8080",
        Handler:        handler,
        ReadTimeout:    10 * time.Second,  // 读取请求超时
        WriteTimeout:   15 * time.Second,  // 写入响应超时
        IdleTimeout:    60 * time.Second,  // 连接空闲超时
        MaxHeaderBytes: 1 << 20,           // 1MB
    }

    fmt.Println("服务器启动在: http://localhost:8080")
    // 启动服务器
    if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        fmt.Printf("服务器启动失败: %s\n", err)
    }
}

优雅关闭¶

在生产环境中，我们需要优雅地关闭服务器（等待当前请求处理完成，而不是强制终止）：

package main

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // 创建处理器
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 模拟耗时操作
        time.Sleep(5 * time.Second)
        fmt.Fprintln(w, "请求处理完成")
    })

    // 配置服务器
    server := &http.Server{
        Addr:           ":8080",
        Handler:        handler,
        ReadTimeout:    10 * time.Second,
        WriteTimeout:   15 * time.Second,
    }

    // 启动服务器（在goroutine中）
    go func() {
        fmt.Println("服务器启动在: http://localhost:8080")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            fmt.Printf("服务器启动失败: %s\n", err)
        }
    }()

    // 等待中断信号
    quit := make(chan os.Signal, 1)
    // 接收SIGINT和SIGTERM信号
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    fmt.Println("正在关闭服务器...")

    // 创建一个5秒超时的上下文
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // 优雅关闭服务器
    if err := server.Shutdown(ctx); err != nil {
        fmt.Printf("服务器关闭失败: %s\n", err)
    }

    fmt.Println("服务器已关闭")
}

Shutdown()与Close()的区别： - Shutdown(ctx)：优雅关闭，等待当前请求处理完成，不再接收新请求 - Close()：强制关闭，立即终止所有活动连接

性能调优¶

根据业务场景调整以下参数：

超时设置：
高并发API服务：适当缩短超时时间（如ReadTimeout=5s, WriteTimeout=10s）
处理耗时任务的服务：适当延长超时时间
MaxHeaderBytes：
常规Web服务：默认值(1MB)通常足够
有大量自定义头的服务：根据实际需求增大
TLS配置：
生产环境必须启用HTTPS，配置TLSConfig提升安全性
并发控制：
通过中间件实现请求限流
根据服务器CPU核心数调整GOMAXPROCS

5. 请求与响应对象解析¶

*http.Request和http.ResponseWriter是处理HTTP交互的核心对象，掌握它们的使用是开发Web服务的基础。

*http.Request：解析请求数据¶

*http.Request包含了客户端请求的所有信息：

package main

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

func requestInfoHandler(w http.ResponseWriter, r *http.Request) {
    // 构建响应内容
    var info strings.Builder

    // 基本信息
    info.WriteString(fmt.Sprintf("请求方法: %s\n", r.Method))
    info.WriteString(fmt.Sprintf("请求URL: %s\n", r.URL.String()))
    info.WriteString(fmt.Sprintf("协议版本: %s\n", r.Proto))
    info.WriteString(fmt.Sprintf("远程地址: %s\n\n", r.RemoteAddr))

    // URL参数
    info.WriteString("URL参数:\n")
    queryParams := r.URL.Query()
    for key, values := range queryParams {
        info.WriteString(fmt.Sprintf("  %s: %v\n", key, values))
    }
    info.WriteString("\n")

    // 请求头
    info.WriteString("请求头:\n")
    for key, values := range r.Header {
        info.WriteString(fmt.Sprintf("  %s: %v\n", key, values))
    }
    info.WriteString("\n")

    // Cookie
    info.WriteString("Cookie:\n")
    cookies := r.Cookies()
    for _, cookie := range cookies {
        info.WriteString(fmt.Sprintf("  %s: %s\n", cookie.Name, cookie.Value))
    }

    // 输出响应
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(info.String()))
}

func main() {
    http.HandleFunc("/request-info", requestInfoHandler)

    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

测试：

curl "http://localhost:8080/request-info?name=Alice&age=30" -H "X-Test: hello" -b "session=123456"

http.ResponseWriter：构造响应¶

http.ResponseWriter用于构建并发送响应给客户端：

package main

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

func responseDemoHandler(w http.ResponseWriter, r *http.Request) {
    // 设置响应头
    w.Header().Set("Content-Type", "text/html; charset=utf-8")
    w.Header().Set("X-Powered-By", "Go")
    w.Header().Add("Cache-Control", "no-store")
    w.Header().Add("Cache-Control", "no-cache")

    // 设置Cookie
    cookie := &http.Cookie{
        Name:    "last_visit",
        Value:   time.Now().Format(time.RFC3339),
        Path:    "/",
        Expires: time.Now().Add(24 * time.Hour),
    }
    http.SetCookie(w, cookie)

    // 设置状态码（默认是200 OK）
    w.WriteHeader(http.StatusOK)

    // 写入响应体
    html := `
    <html>
        <head><title>响应示例</title></head>
        <body>
            <h1>Hello, Response!</h1>
            <p>当前时间: %s</p>
        </body>
    </html>
    `
    fmt.Fprintf(w, html, time.Now().Format(time.RFC3339))
}

func main() {
    http.HandleFunc("/response-demo", responseDemoHandler)

    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

实战：实现用户信息处理器¶

下面是一个综合示例，实现一个获取和提交用户信息的处理器：

package main

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

// 用户结构体
type User struct {
    ID       int    `json:"id"`
    Name     string `json:"name"`
    Email    string `json:"email"`
    Age      int    `json:"age"`
    CreateAt string `json:"create_at"`
}

// 模拟数据库
var users = map[int]User{
    1: {
        ID:       1,
        Name:     "张三",
        Email:    "zhangsan@example.com",
        Age:      30,
        CreateAt: "2023-01-01",
    },
    2: {
        ID:       2,
        Name:     "李四",
        Email:    "lisi@example.com",
        Age:      25,
        CreateAt: "2023-02-15",
    },
}

// 获取用户信息
func getUserHandler(w http.ResponseWriter, r *http.Request) {
    // 从URL路径中获取用户ID
    // 假设路径是 /user/1
    parts := splitPath(r.URL.Path)
    if len(parts) < 3 {
        http.Error(w, "无效的URL", http.StatusBadRequest)
        return
    }

    id, err := strconv.Atoi(parts[2])
    if err != nil {
        http.Error(w, "无效的用户ID", http.StatusBadRequest)
        return
    }

    // 查询用户
    user, exists := users[id]
    if !exists {
        http.Error(w, "用户不存在", http.StatusNotFound)
        return
    }

    // 设置响应头为JSON类型
    w.Header().Set("Content-Type", "application/json; charset=utf-8")
    w.WriteHeader(http.StatusOK)

    // 转换为JSON并发送
    json.NewEncoder(w).Encode(user)
}

// 辅助函数：分割URL路径
func splitPath(path string) []string {
    parts := strings.Split(path, "/")
    // 过滤空字符串
    result := []string{}
    for _, part := range parts {
        if part != "" {
            result = append(result, part)
        }
    }
    return result
}

import "strings" // 上面的splitPath函数需要导入strings包

func main() {
    http.HandleFunc("/user/", getUserHandler)

    fmt.Println("服务器启动在: http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

测试：

curl http://localhost:8080/user/1
curl http://localhost:8080/user/999  # 测试不存在的用户

这个示例展示了： 1. 如何解析URL路径参数 2. 如何根据不同情况返回适当的HTTP状态码 3. 如何构建JSON响应 4. 如何处理错误情况并返回友好的错误信息

总结¶

net/http包为Go语言提供了强大而灵活的Web开发能力，通过本文介绍的核心组件： - Handler接口与处理器函数 - ServeMux路由管理 - Server结构体配置 - Request与ResponseWriter对象

你已经掌握了Go原生Web开发的基础知识。这些组件设计简洁但功能强大，能够满足从简单API到复杂Web应用的各种需求。在实际开发中，你可以根据业务场景灵活组合这些组件，构建高性能、可维护的Web服务。

本节重点：理解net/http包的核心设计，掌握HTTP服务器开发的基础技能，为后续学习Web框架打下坚实基础。