Go HTTP模块处理流程简析

Go语言提供完善的net/http包，用户使用起来非常方便简单，只需几行代码就可以搭建一个简易的Web服务，可以对Web路由、静态文件、cookie等数据进行操作。

一个使用http包建立的Web服务

package main

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

func RequestHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World")
}

func main() {
    http.HandleFunc("/", RequestHandler)

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe:", err)
    }
}

核心代码代码如下，下面对它们进行解析

// 用户自定义HTTP路由句柄
func RequestHandler(w http.ResponseWriter, r *http.Request)

// Multiplexer路由注册
http.HandleFunc("/", RequestHandler)

// 服务器监听本地地址，并循环处理HTTP请求
http.ListenAndServe(":8080", nil)

创建ServeMux路由handler

func RequestHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World")
}

这个是用户自定义的函数，结合第二行代码看，作为http.HandleFunc函数调用的第二个参数，因为http.HandleFunc第二个参数类型是func(ResponseWriter, *Request)，所以本函数定义带有(ResponseWriter, *Request)参数列表，无返回值。第一个参数http.ResponseWriter是一个接口，用于对一次HTTP请求做响应处理，第二个参数http.Request是一次HTTP请求实例，后面再做详细分析。本函数本质上是一个http请求处理的回调函数，是由http包框架开放出，用户可以自定义处理函数。

ServeMux路由表结构

Go默认路由表结构为ServerMux

// ServeMux结构是一个HTTP请求多路复用器(Multiplexer)
type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry   // ServeMux路由表
    hosts bool // whether any patterns contain hostnames
}

// 路由表项
type muxEntry struct {
    h       Handler // 请求处理handler
    pattern string  // 请求路径
}

ServeMux路由注册过程过程

// 往系统默认的ServerMux中添加一条路由
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

// 系统默认的Multiplexer：ServeMux
var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    
    // 将用户定义的handler方法，强转为HandlerFunc类型，即实现Handler接口，
    // 后面直接通过f.ServeHTTP(w, r)实现对用户注册的handler的调用，f类型为HandlerFunc
    mux.Handle(pattern, HandlerFunc(handler))
}

// HandlerFunc类型
type HandlerFunc func(ResponseWriter, *Request)

// HandlerFunc类型实现了Handler接口中ServeHTTP方法
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

// 往ServeMux路由表（mux.m，map结构）中添加路由
func (mux *ServeMux) Handle(pattern string, handler Handler) {
    mux.mu.Lock()
    defer mux.mu.Unlock()

    if pattern == "" {
        panic("http: invalid pattern")
    }
    if handler == nil {
        panic("http: nil handler")
    }
    if _, exist := mux.m[pattern]; exist {
        panic("http: multiple registrations for " + pattern)
    }

    if mux.m == nil {
        mux.m = make(map[string]muxEntry)
    }
    // 向路由表中新增路由表项
    mux.m[pattern] = muxEntry{h: handler, pattern: pattern}

    // 如果不是以'/'开头，则从host开始匹配
    if pattern[0] != '/' {
        mux.hosts = true
    }
}

ServeMux路由匹配过程

// 见net/http/server.go中func (c *conn) serve(ctx context.Context) 1847行（Go SDK 1.11.5）
// 这里就完成对用户注册的路由handler调用
serverHandler{c.server}.ServeHTTP(w, w.req)

// serverHandler类型
type serverHandler struct {
    srv *Server
}

// serverHandler也实现了Handler接口中ServeHTTP方法
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
    // http.ListenAndServe(":8080", nil)中第二个参数为nil，表示使用系统默认Multiplexer：DefaultServeMux，
    // 在这里就启用DefaultServeMux，可以查看Server结构对Handler成员注释说明(handler to invoke, http.DefaultServeMux if nil)
    handler := sh.srv.Handler
    if handler == nil {
        handler = DefaultServeMux
    }
    if req.RequestURI == "*" && req.Method == "OPTIONS" {
        handler = globalOptionsHandler{}
    }
    // 调用ServeMux实现Handler接口中ServeHTTP方法
    handler.ServeHTTP(rw, req)
}

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    if r.RequestURI == "*" {
        if r.ProtoAtLeast(1, 1) {
            w.Header().Set("Connection", "close")
        }
        w.WriteHeader(StatusBadRequest)
        return
    }
    // 通过Request找到路由
    h, _ := mux.Handler(r)

    // 到这里就调用用户注册的路由Handler
    h.ServeHTTP(w, r)
}

// 进一步跟踪mux.Handler(r)
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
    // ...
    return mux.handler(host, r.URL.Path)
}

func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
    mux.mu.RLock()
    defer mux.mu.RUnlock()

    // 通过路径匹配路由
    if mux.hosts {
        h, pattguizeern = mux.match(host + path)
    }
    if h == nil {
        h, pattern = mux.match(path)
    }
    if h == nil {
        h, pattern = NotFoundHandler(), ""
    }
    return
}

func (mux *ServeMux) match(path string) (h Handler, pattern string) {
    // Check for exact match first.
    v, ok := mux.m[path]
    if ok {
        return v.h, v.pattern
    }

    // Check for longest valid match.
    var n = 0
    for k, v := range mux.m {
        if !pathMatch(k, path) {
            continue
        }
        // 匹配时选择匹配度最高的路由(长匹配优先于短匹配)
        if h == nil || len(k) > n {
            n = len(k)
            h = v.h
            pattern = v.pattern
        }
    }
    return
}

// 如果pattern不是以'/'结尾，则需完全匹配
// 如果pattern是以'/'结尾，并且pattern（/tree/）是path(/tree/xxx)的前缀子串，
// 则path(/tree/xxx)属于pattern(/tree/*)路由子集下，后面通过match中for语句，基于长匹配优先于短匹配原则，完全匹配路由
func pathMatch(pattern, path string) bool {
    if len(pattern) == 0 {
        // should not happen
        return false
    }
    n := len(pattern)
    if pattern[n-1] != '/' {
        return pattern == path
    }
    return len(path) >= n && path[0:n] == pattern
}

ServeMux路由匹配规则

对于每个HTTP请求，ServeHTTP会对URL进行模式（pattern）匹配，然后调用注册在此pattern下的handler来处理当前请求。

1、如果pattern以'/'开头，表示匹配URL的路径部分，如果不是以'/'开头，表示从host开始匹配；
2、模式匹配时，以匹配度最高为原则（长匹配优先于短匹配）；
3、如果pattern（/tree/）以'/'结尾，将会对不带'/'的URL（/tree）进行301重定向到'/tree/'上，除非单独为'/tree'模式注册handler；
4、如果pattern（/tree）注册了handler，当请求的路径为'/tree/'时，则无法匹配该模式；

实现Handler接口

Handler结构定义如下

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

net/http/server.go中实现Handler接口有以下方法

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {f(w, r)}
func (rh *redirectHandler) ServeHTTP(w ResponseWriter, r *Request)
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request)
func (h *timeoutHandler) ServeHTTP(w ResponseWriter, r *Request)
func (globalOptionsHandler) ServeHTTP(w ResponseWriter, r *Request)
func (h initNPNRequest) ServeHTTP(rw ResponseWriter, req *Request)