Go底层之http标准库服务端实现原理分析

目录

• 背景
• 核心数据结构
• 【1】Server对象
• 【2】Handler对象
• 【3】ServeMux对象
• 服务端代码示例
• 路由注册
• 路由匹配
• 总结

http协议的交互框架是C-S架构，C对应客户端模块，S对应服务端模块，接下来我们就基于Go1.23源码来熟悉http标准库中服务端的实现。

位于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 //用于等待所有监听器关闭的同步组
}

位于net/http/server.go文件，其源码如下：

/*
	Handler接口定义了HTTP请求处理器的标准行为，任何实现ServerHTTP方法的类型都可以处理HTTP请求。
	Request：包含HTTP请求的所有信息。
	ResponseWriter：用于构造HTTP响应。
*/
type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

位于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及之前旧版本路由实现
}

使用http标准库实现的一个简单http服务示例如下：

func main() {
	//路由注册
	http.HandleFunc("POST /xxx", func(writer http.ResponseWriter, request *http.Request) {
		writer.Write([]byte("AAA"))
	})

	//服务启用、路由匹配
	http.ListenAndServe(":8000", nil)
}

可以看到一个http服务端由两个部分组成：路由注册和服务启用，其中服务启用内部实现了路由匹配逻辑，接下来再深究内部。

路由注册的入口为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)
}

路由匹配的逻辑在服务启动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)
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持风君子博客。

您可能感兴趣的文章:

• go标准库net/http服务端的实现示例
• 一文带你吃透Golang中net/http标准库服务端
• Go标准库http server的优雅关闭深入理解
• Go标准库http server优雅启动深入理解
• 快速掌握Go 语言 HTTP 标准库的实现方法
• Go标准库http与fasthttp服务端性能对比场景分析