net/http 框架源码解读

一、Hello World

使用net/http编写一个简单的web服务器, 定义了一个UserHandler的处理函数，通过HandleFunc来将路由和handler进行绑定，最后通过ListenAndServe启动web服务，后面我将handler统称为视图函数

package main

import "net/http"

func UserHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World!"))
}

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

二、http.HandlFunc 源码解析

HandleFunc 接受两个参数，第一个是路由地址，第二个是一个视图函数，该函数接受两个参数 ResponseWriter 和 *Request ，前者是用来处理http请求的响应，后者是用来处理http请求的参数。

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	DefaultServeMux.HandleFunc(pattern, handler)
}

DefaultServeMux 是一个结构体变量，真实的结构体是ServeMux。

var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

type ServeMux struct {
	mu    sync.RWMutex
	m     map[string]muxEntry
	es    []muxEntry // slice of entries sorted from longest to shortest.
	hosts bool       // whether any patterns contain hostnames
}

type muxEntry struct {
	h       Handler
	pattern string
}

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

ServeMux 有4个字段

第一个字段是读写锁，
第二个字段是一个map，key其实是路由地址，val是一个muxEntry结构体，该结构体由路由地址和Handler接口组成。
第三个字段是muxEntry切片，这个字段是用来处理存储路由地址是/结尾的，比如/abc/d/，并且将最长的pattern从长到短进行排序，后面的代码会做解释。

ServeMux （DefaultServeMux）定义了一个HandleFunc方法，该方法就是将用户的路由地址和视图函数继续传递给Handle方法，并判断视图函数是否为空。

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	if handler == nil {
		panic("http: nil handler")
	}
	mux.Handle(pattern, HandlerFunc(handler))
}

mux.Handle(pattern, HandlerFunc(handler)) 中HandlerFunc() 是将用户传递的视图函数转为 HandlerFunc 类型，并不是函数调用。

type HandlerFunc func(ResponseWriter, *Request)

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

这里为什么要将视图函数转为HandlerFunc呢？在上面的代码中muxEntry结构体存储一个Handler接口，这个接口的定义了一个ServerHTTP方法，你会发现HandlerFunc恰好实现一个ServeHTTP方法，所以HandlerFunc相当于实现了Handler接口，这样用户定义的视图函数就可以赋值给muxEntry结构体的h字段了。
HandlerFunc 类型是一种适配器，允许将普通函数用作 HTTP 处理程序。

我们接着往下看mux.Handle内部，给ServeMux结构体初始化，并将视图函数和路由地址加载到m字段和es字段中。

func (mux *ServeMux) Handle(pattern string, handler Handler) {
    // 校验路由地址是否已经定义过了。
	if _, exist := mux.m[pattern]; exist {
		panic("http: multiple registrations for " + pattern)
	}

    // 初始化 m 字段
	if mux.m == nil {
		mux.m = make(map[string]muxEntry)
	}
    // 构造muxEntry结构体，并将视图函数和路由地址传入。
	e := muxEntry{h: handler, pattern: pattern}
	mux.m[pattern] = e
    // 如果路由地址最后是以 / 结尾，则将mux.es切片进行排序后重新赋值给mux.es
	if pattern[len(pattern)-1] == '/' {
		mux.es = appendSorted(mux.es, e)
	}

	if pattern[0] != '/' {
		mux.hosts = true
	}
}

appendSorted 函数内部主要是将路由地址从长到短进行排序后返回[]muxEntry，并重新赋值给ServeMux结构体的es字段。

以上就是HandlFunc的源码，还是挺简单的，主要做的事情就是将用户定义的路由地址和视图函数填充到ServeMux结构体

三、http.ListenAndServe 源码解析

func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}

ListenAndServe接受一个地址和一个Handler接口，然后实例化Server结构体，然后调用Server的ListenAndServe方法。
Server 结构体由很多字段，包含TSL配置，读取超时时间，响应超时时间等。

type Server struct {
	Addr string

	Handler Handler // handler to invoke, http.DefaultServeMux if nil

	TLSConfig *tls.Config

	ReadTimeout time.Duration

	ReadHeaderTimeout time.Duration

	WriteTimeout time.Duration
    ......
}

ListenAndServe 对用户传递的addr进行校验，然后使用net.Listen创建监听对象，并传入Serve方法。

Serve 方法中我去掉了一些代码，保留了主要部分，baseCtx 主要用来保存整个请求生命周期的上下文，
这里有一个指数退避策略的用法。如果l.Accept()调用返回错误，我们判断该错误是不是临时性地（ne.Temporary()）。如果是临时性错误，Sleep一小段时间后重试，每发生一次临时性错误，Sleep的时间翻倍，最多Sleep 1s。获得新连接后，将其封装成一个conn对象（srv.newConn(rw)），创建一个 goroutine 运行其serve()方法。省略无关逻辑的代码如下：

func (srv *Server) Serve(l net.Listener) error {
    ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    var tempDelay time.Duration // how long to sleep on accept failure
    for {
        rw, err := l.Accept()
        if err != nil {
            if srv.shuttingDown() {
                return ErrServerClosed
            }
            if ne, ok := err.(net.Error); ok && ne.Temporary() {
                if tempDelay == 0 {
                    tempDelay = 5 * time.Millisecond
                } else {
                    tempDelay *= 2
                }
                if max := 1 * time.Second; tempDelay > max {
                    tempDelay = max
                }
                srv.logf("http: Accept error: %v; retrying in %v", err, tempDelay)
                time.Sleep(tempDelay)
                continue
            }
            return err
        }
        connCtx := ctx
        tempDelay = 0
        c := srv.newConn(rw)
        c.setState(c.rwc, StateNew, runHooks) // before Serve can return
        go c.serve(connCtx)
    }
}

serve()方法其实就是不停地读取客户端发送地请求，创建serverHandler对象调用其ServeHTTP()方法去处理请求，然后做一些清理工作。serverHandler只是一个中间的辅助结构，关键点就在于 ServeHTTP方法。

func (c *conn) serve(ctx context.Context) {
    c.remoteAddr = c.rwc.RemoteAddr().String()
    ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())

    for {
        // 读取请求内容
        w, err := c.readRequest(ctx)
        // 执行用户的视图函数
        serverHandler{c.server}.ServeHTTP(w, w.req)
        // 返回响应
        w.finishRequest()
    }
}

ServeHTTP方法先判断Handler（Server结构体中的Handler，在http.ListenAndServe(":8080", nil)时，这个nil其实就是作为handler参数传入的）若为nil则使用默认的DefaultServeMux，这时就会发现通过http.HandlerFunc函数将路由和视图函数塞进了DefaultServeMux结构体被使用到了。

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	handler := sh.srv.Handler
	if handler == nil {
		handler = DefaultServeMux
	}
	handler.ServeHTTP(rw, req)
}

handler.ServeHTTP(rw, req) 就相当于调用了DefaultServeMux结构体的ServeHTTP方法，并将前面读取到的请求内存和封装的响应w传递进去
ServeMux结构体的ServeHTTP方法内部通过调用mux.Handler(r)方法来获得一个Handler接口，最后调用h接口的ServeHTTP方法。
那么h接口是由什么类型实现呢？我们往后看。

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    // 返回用户的视图函数，是HandleFunc类型。
    h, _ := mux.Handler(r)
    h.ServeHTTP(w, r)
}

mux.Handler(r ) 调用

mux.Handler(r) 方法最后调用handler方法，通过用户请求的地址，使用match方法来匹配视图函数并返回。

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) {
	h, pattern = mux.match(path)
	return
}

func (mux *ServeMux) match(path string) (h Handler, pattern string) {
	// Check for exact match first.
    // 检测path是否存在ServeMux的m中
	v, ok := mux.m[path]
	if ok {
		return v.h, v.pattern
	}

	// Check for longest valid match.  mux.es contains all patterns
	// that end in / sorted from longest to shortest.
    // 匹配路由地址是否为/结尾的路由中的一部分
    // 比如/ab 是满足 /ab/c/的前缀匹配。注意es中是已经按照路由从长到短排序过了的。
	for _, e := range mux.es {
		if strings.HasPrefix(path, e.pattern) {
			return e.h, e.pattern
		}
	}
	return nil, ""
}

h.ServeHTTP(w, r) 调用

前面 h, _ := mux.Handler(r)返回的h就是HandlerFunc 类型转换后的视图函数，所以就相当于调用HandlerFunc类型的ServeHTTP方法
ServeHTTP方法内部就是调用自身，也就是执行了用户的视图函数。

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

最后在w.finishRequest()方法返回响应，至此从定义视图函数，到接受请求并执行视图函数，最后返回响应体的基本路线已经完成了。

附上两张调用流程图，我觉得图片做的挺好的。
图片来源：https://blog.csdn.net/s2603898260/article/details/121575056

参考文章：https://darjun.github.io/2021/07/13/in-post/godailylib/nethttp/