1、背景
http协议的交互框架是C-S架构，C对应客户端模块，S对应服务端模块，接下来我们就基于Go1.23源码来熟悉http标准库中服务端的实现。
2、核心数据结构
【1】Server对象
位于net/http/server.go文件，其源码如下：
type Server struct {
Addr string //服务器监听规定TCP地址
Handler Handler //处理http请求的处理器。若为nil，使用http.DefaultServeMux
DisableGeneralOptionsHandler bool //若为true，将OPTIONS*请求交给Handler处理，否在自动响应200 OK
TLSConfig *tls.Config //TLS配置
ReadTimeout time.Duration //读取整个请求（含请求体）的最大超时时间。若小于等于0，表示无超时
ReadHeaderTimeout time.Duration //单独读取请求头的超时时间。若小于等于0，继承ReadTimeout的值
WriteTimeout time.Duration //写入响应的最大超时时间。若小于等于0，表示无超时
IdleTimeout time.Duration //保持连接空闲的最大时间（用于keep-Alice）若小于等于0，继承ReadTimeout的值
MaxHeaderBytes int //请求头的最大字节数。若为0，使用DefaultMaxHeaderBytes
TLSNextProto map[string]func(*Server, *tls.Conn, Handler) //用于处理ALPN协议升级
ConnState func(net.Conn, ConnState) //客户端连接状态变更时的回调函数（如新建、活跃、空闲、关闭）
ErrorLog *log.Logger //自定义错误日志记录器。若为nil，则使用标准库的log包
BaseContext func(net.Listener) context.Context //为每个请求生成基础上下文
ConnContext func(ctx context.Context, c net.Conn) context.Context //修改新连接的上下文
inShutdown atomic.Bool //标记服务器是否正在关闭
disableKeepAlives atomic.Bool //控制是否禁用Keep-Alive
nextProtoOnce sync.Once //确保HTTP/2配置只初始化一次
nextProtoErr error //存储HTTP/2配置的错误结果
mu sync.Mutex //保护listeners和activceConn
listeners map[*net.Listener]struct{} //当前活跃的监听器集合
activeConn map[*conn]struct{} //当前活跃的连接集合
onShutdown []func() //服务器关闭时执行的钩子函数
listenerGroup sync.WaitGroup //用于等待所有监听器关闭的同步组
}
【2】Handler对象
位于net/http/server.go文件，其源码如下：
/*
Handler接口定义了HTTP请求处理器的标准行为，任何实现ServerHTTP方法的类型都可以处理HTTP请求。
Request：包含HTTP请求的所有信息。
ResponseWriter：用于构造HTTP响应。
*/
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
【3】ServeMux对象
位于net/http/server.go文件，其源码如下：
/*
ServeMux是HTTP请求路由器的核心实现，复杂将不同URL路径的请求分发给对应的处理函数。
其核心作用是通过内部的路由树（tree）和索引（index）高效匹配请求路径，同时通过互斥
锁（mu）保证并发安全，并兼容旧版本路由逻辑（mux121）。
*/
type ServeMux struct {
mu sync.RWMutex //保护路由表的并发安全（注册路由时写锁，匹配路由时读锁）
tree routingNode //路由前缀树，存储URL路径与处理函数的映射关系，支持高效路径匹配
index routingIndex //路由加速索引，优化特定场景的查找性能
patterns []*pattern //兼容旧版本的路由模式列表
mux121 serveMux121 //Go1.21及之前旧版本路由实现
}
3、服务端代码示例
使用http标准库实现的一个简单http服务示例如下：
func main() {
//路由注册
http.HandleFunc("POST /xxx", func(writer http.ResponseWriter, request *http.Request) {
writer.Write([]byte("AAA"))
})
//服务启用、路由匹配
http.ListenAndServe(":8000", nil)
}
可以看到一个http服务端由两个部分组成：路由注册和服务启用，其中服务启用内部实现了路由匹配逻辑，接下来再深究内部。
4、路由注册
路由注册的入口为http.HandleFunc函数，其源码如下：
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
if use121 {
//Go1.21及以前版本路由注册实现
DefaultServeMux.mux121.handleFunc(pattern, handler)
} else {
//新版本路由注册实现
DefaultServeMux.register(pattern, HandlerFunc(handler))
}
}
旧版本路由注册实现源码如下：
func (mux *serveMux121) handleFunc(pattern string, handler func(ResponseWriter, *Request)) {
...
//将路径和对应的回调函数关联起来，具体关联方法不深究
mux.handle(pattern, HandlerFunc(handler))
}
新版本路由注册实现源码如下：
func (mux *ServeMux) registerErr(patstr string, handler Handler) error {
...
pat, err := parsePattern(patstr)
if err != nil {
return fmt.Errorf("parsing %q: %w", patstr, err)
}
...
//关联路径和对应的回调函数
mux.tree.addPattern(pat, handler)
mux.index.addPattern(pat)
mux.patterns = append(mux.patterns, pat)
return nil
}
旧版本和新版本都会将对应的回调函数转换为http.HandlerFunc类型，这是因为http.HandlerFunc类型实现了http.Handler接口：
//实现了Handler接口
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
5、路由匹配
路由匹配的逻辑在服务启动http.ListenAndServe里，其源码调用逻辑链路为：
func ListenAndServe(addr string, handler Handler) error {
server := &Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}
func (srv *Server) ListenAndServe() error {
...
ln, err := net.Listen("tcp", addr)
if err != nil {
return err
}
return srv.Serve(ln)
}
func (srv *Server) Serve(l net.Listener) error {
...
for {
rw, err := l.Accept() //阻塞等待客户端连接
...
c := srv.newConn(rw)
c.setState(c.rwc, StateNew, runHooks) // before Serve can return
go c.serve(connCtx) //协程去响应客户端连接
}
}
func (c *conn) serve(ctx context.Context) {
...
for {
//读取客户端请求并构造响应结构体w
w, err := c.readRequest(ctx)
...
//处理并响应请求
serverHandler{c.server}.ServeHTTP(w, w.req)
...
}
}
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
handler := sh.srv.Handler
if handler == nil { //未定义handler就使用默认的http处理器
handler = DefaultServeMux
}
...
//处理客户端请求并响应
handler.ServeHTTP(rw, req)
}
//默认http处理器实现的处理客户端请求并响应的方法
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
...
var h Handler
if use121 { //旧版本根据请求进行路由匹配
h, _ = mux.mux121.findHandler(r)
} else { //新版本根据请求进行路由匹配
h, r.Pattern, r.pat, r.matches = mux.findHandler(r)
}
/*
这里执行的是HandlerFunc类型的ServeHTTP方法，因为在注册路由时都将回调函数转换为了HandlerFunc类型。
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
*/
h.ServeHTTP(w, r)
}