golang源码解读之http.server

关于server.go

server.go 里实现了 在发送请求后服务器如何对请求做出相对应响应的方法。开发人员只需要根据几行代码就可以直接 快速搭建http server服务。如下：
编写handler处理函数–>注册路由–>创建服务并开启监听

// 请求处理函数
func indexHandler(w http.ResponseWriter, r *http.Request) {
   
	_, _ = io.WriteString(w, "hello, world!\n")
}

func main() {
   
	http.HandleFunc("/", indexHandler)	// （默认ServeMux对象）注册路由(定义处理函数)
	err := http.ListenAndServe(":8001", nil)	// （封装Server对象）创建服务并开启监听
	if err != nil {
   
		log.Fatal("ListenAndServe: ", err)
	}
}

因此，请求会先进入路由，路由为请求找到合适的handler，handler对request进行处理，并构建response传给客户端

源码解析

1、服务器如何接收到客户端发出的请求?这里有一个重要对象：Server结构

// Server 是一个http服务对象， 是一个http服务的总体数据结构。
type Server struct {
   
	Addr string     	// 指定要侦听的服务器的TCP地址,为空时:http (端口 80)
	Handler Handler		// 所有请求需要调用的Handler（实际上是ServeMux）如果为空则为DefaultServeMux
	TLSConfig *tls.Config	// 供ServeTLS和ListenAndServeTLS使用的TLS配置
	ReadTimeout time.Duration	// 读整个请求的最大时间，可和deadline 兼用
	ReadHeaderTimeout time.Duration		// 读请求头的最大时间，deadline被重置
	WriteTimeout time.Duration	// 是响应写入超时之前的最长持续时间
	IdleTimeout time.Duration	// 启用keep alives时等待下一个请求的最长时间.如果t为零，则使用ReadTimeout。如果两者都为零，则不存在超时
	MaxHeaderBytes int	// 解析请求头的键和值（包括请求行）时服务器将读取的最大字节数

	// 可选地指定一个函数，以便在发生ALPN协议升级时接管所提供的TLS连接的所有权,key是协商的协议名称
	// 传参Handler用于处理HTTP请求，如果尚未设置，则将初始化请求的TLS和RemoteAddr。
	// 当函数返回时，连接将自动关闭
	TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
	ConnState func(net.Conn, ConnState)	// 指定一个可选回调函数，当客户端连接更改状态时调用该函数。
	ErrorLog *log.Logger	// 接受连接的错误、处理程序的意外行为和底层文件系统错误指定可选的记录器

	BaseContext func(net.Listener) context.Context// 指定一个函数返回此服务器上传入请求的基本上下文
	ConnContext func(ctx context.Context, c net.Conn) context.Context// 指定函数修改 新连接c上下文

	inShutdown atomicBool  //当服务器关闭时为true
	...
	mu         sync.Mutex
	listeners  map[*net.Listener]struct{
   }
	activeConn map[*conn]struct{
   }
	doneChan   chan struct{
   }
	onShutdown []func()
}

1.1、 关于 Server.Handler字段为何定义成 Handler接口类型
该字段实际是一个ServeMux结构体对象，但这里定义成了Handler接口。具体解析后面有
该字段的5个使用处发现：只有第三个函数会 判断 Server.Handler字段 可能不是ServeMux类型 而是 globalOptionsHandler 结构体，所以Server的处理程序字段必须是Handler接口类型，而不仅仅是ServeMux结构体
①外部调用方法 根据监听器 处理http请求的Serve()、②ServeTLS()、③serverHandler对象的ServeHTTP()方法会调用Handler字段（其中判断了如果是OPTION*请求时，需要另外设置一个新的 处理程序）、④外部调用方法 使用处理程序 处理addr的 ListenAndServe()、⑤ListenAndServeTLS()

func Serve(l net.Listener, handler Handler) error {
   
func ServeTLS(l net.Listener, handler Handler, certFile, keyFile string) error {
   
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
   
func ListenAndServe(addr string, handler Handler) error {
   
func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error {
   

1.2、该server对象提供的一些方法

func (srv *Server) Serve(l net.Listener) error   //对某个端口进行监听，里面是调用for进行accept的处理
func (srv *Server) ListenAndServe() error  //开启http server服务，内部调用Serve
func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error //开启https server服务，内部调用Serve

贴出核心源码：核心逻辑包括：监听端口、等待连接、创建连接、处理请求

其中 Serve()方法：传入监听器，使用监听器的传入连接，为每个连接创建一个新的服务goroutine(服务goroutines读取请求，然后调用srv.Handler回复他们； 该函数主要包装监听器，然后判断上下文，设置休眠循环监听，根据上下文调用内部方法serve实现

func (srv *Server) Serve(l net.Listener) error {
   
	// 1、 使用未包装的监听器调用hook
	if fn := testHookServerServe; fn != nil {
   
		fn(srv, l)
	}

	// 2、包装监听器
	origListener := l
	l = &onceCloseListener{
   Listener: l}
	defer l.Close()

	// 3、在srv上有条件地配置HTTP/2
	if err := srv.setupHTTP2_Serve(); err != nil {
   
		return err
	}

	// 4、 将l添加到已跟踪的 监听器集，之后便删除
	if !srv.trackListener(&l, true) {
   
		return ErrServerClosed
	}
	defer srv.trackListener(&l, false)

	baseCtx := context.Background()
	// 5、如果已经存在上下文，则设置成 背景上下文
	if srv.BaseContext != nil {
   
		baseCtx = srv.BaseContext(origListener)
		if baseCtx == nil {
   
			panic("BaseContext returned a nil context")
		}
	}

	var tempDelay time.Duration // 接受失败要休眠的时间

	// 6、取出"http-server"为key的上下文
	ctx := context.WithValue(baseCtx, ServerContextKey, srv)
	for {
   
		// 7、 循环等待并返回到监听器的下一个连接
		rw, err := l.Accept()
		if err != nil {
   
			select