Go Web 核心原理：Handler 与 ServerMux 深度解析

muxEntry 就是路由项。你注册的每一个路由规则都会被放入这个 map 中：

http.HandleFunc("/login", Login)
http.HandleFunc("/", Index)

内部会被转换为：

map[string]muxEntry {
    "/": {explicit: true, h: Index},
    "/login": {explicit: true, h: Login},
}

这个 map 告诉 ServeMux：访问某个路径时，应该调用哪一个 handler。

Handler 是什么

在 Go 中，Handler 是一个接口：

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

只要一个类型实现了 ServeHTTP 方法，它就是一个 Handler。所有 HTTP 请求最终都通过调用某个实现了 Handler 接口的类型的 ServeHTTP 方法来处理。

平时我们写的普通函数：

func login(w http.ResponseWriter, r *http.Request) {}

它是如何变成 Handler 的呢？底层关系如下：

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

也就是说：

• HandlerFunc 是一个函数类型，但它实现了 Handler 接口。
• HandlerFunc(pattern, fn) 内部实际上是调用了 Handle(pattern, HandlerFunc(fn))。

换句话说，HandlerFunc 是 Handle 的便捷封装，专为函数风格设计。

http.DefaultServeMux 是一个全局默认的 ServeMux 实例。当你调用 http.Handle() 或 http.HandleFunc() 时，实际上是向 DefaultServeMux 注册路由。而 ServerMux 本身也实现了 Handler 接口（因为它有 ServeHTTP 方法），所以它可以作为根处理器传给服务器。

Handler 的职责非常清晰：读取请求数据、执行业务逻辑、写入响应数据。它不关心端口监听、路由匹配、并发调度或 TCP 连接管理。

示例：

func Index(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello golang Web"))
}

func main() {
    http.HandleFunc("/index", Index)
    http.ListenAndServe(":8080", nil)
}

实际上，Index 函数被适配成了一个 Handler。

当请求到来时，流程如下：

1. 请求路径 /index
2. ServerMux 查找最匹配的路径
3. 返回对应的 Handler
4. 调用 Handler.ServeHTTP

Handler 的一次调用，只服务于一次 HTTP 请求。

自定义根处理器

其实我们可以完全不用 ServerMux，因为 http.ListenAndServe() 的第二个参数就是 Handler，可以传入任意实现 ServeHTTP 的对象，包括自定义路由器。

type MyRouter struct{}

func (mr *MyRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/users" {
        w.Write([]byte("用户列表..."))
    } else {
        http.NotFound(w, r)
    }
}

// 启动
// http.ListenAndServe(":8080", &MyRouter{})

业务处理

流程很简单：读取请求 → 执行业务逻辑 → 写入响应。

当读取请求之后，就可以在 Handler 函数里面写入业务逻辑了。针对这样一个函数：

func Index(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello Go Web"))
}

这两个参数对应的功能分别是：

• w http.ResponseWriter（接口）：用于写入 HTTP 响应，即发送回给浏览器的所有内容。
• r *http.Request（结构体指针）：表示当前收到的客户端 HTTP 完整请求，包含浏览器发过来的所有信息。

Request —— 请求（客户端 -> 服务器）

type Request struct {
    Method string       // GET / POST / PUT ...
    URL    *url.URL     // 请求的 URL
    Header Header       // 请求头
    Body   io.ReadCloser // 请求体
    ...
}

这是浏览器这次请求的完整信息，我们能从 r 中获得：

（1）请求方式

r.Method

支持 GET、POST、PUT、DELETE 等，常用于判断逻辑。

（2）URL 和路径

r.URL.Path      // /index
r.URL.RawQuery  // a=1&b=2

例如：http://localhost:8080/index?a=1&b=2

（3）查询参数（GET 参数）

name := r.URL.Query().Get("name")

（4）请求头 Header

r.Header.Get("User-Agent")
r.Header.Get("Content-Type")

请求头包含了浏览器信息、JSON 格式、表单类型等信息。

（5）请求体 Body（POST / PUT）

r.Body

包含表单数据、JSON、文件上传等内容。

注意：Body 只能读一次，本质上是一个流。

ResponseWriter—— 响应（服务器 → 客户端）

type ResponseWriter interface {
    Header() Header
    Write([]byte) (int, error)
    WriteHeader(statusCode int)
}

这是服务器响应的工具，其中 w 可以做以下操作：

（1）写响应体（最常用）

w.Write([]byte("Hello go web"))

也就是浏览器看到的内容。

（2）写状态码

w.WriteHeader(http.StatusOK)       // 200
w.WriteHeader(http.StatusNotFound) // 404

注意：只能写一次，如果不写，默认是 200。

（3）设置响应头

w.Header().Set("Content-Type", "text/html")

必须在 Write() 之前设置。

完整示例

func Index(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/plain")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("Hello Go Web"))
}

两者配合的完整流程

浏览器 
  ↓ Request (r) 
  ↓ Index(w, r) 
  ↓ ResponseWriter (w) 
  ↓ 浏览器显示结果

这时有人可能会问：为什么 r 是指针，而 w 不是？

r *http.Request 是指针

• Request 结构体很大，避免拷贝。
• Handler 可能需要修改它的一些字段。

w http.ResponseWriter 是接口

• 屏蔽底层实现。
• 可以是 HTTP/1.1、HTTP/2 或测试用的 mock。

这也是 Go 的经典设计：接口 + 组合。

以上这些内容在相关流行框架中通常会被进一步封装，便于开发使用。但理解这些基础组件，始终是掌握 Go Web 编程本质的关键。