type Server struct {
	Addr string //服務器監(jiān)聽規(guī)定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 //請求頭的最大字節(jié)數(shù)。若為0，使用DefaultMaxHeaderBytes

	TLSNextProto map[string]func(*Server, *tls.Conn, Handler) //用于處理ALPN協(xié)議升級

	ConnState func(net.Conn, ConnState) //客戶端連接狀態(tài)變更時的回調函數(shù)（如新建、活躍、空閑、關閉）

	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{} //當前活躍的監(jiān)聽器集合
	activeConn map[*conn]struct{} //當前活躍的連接集合
	onShutdown []func() //服務器關閉時執(zhí)行的鉤子函數(shù)

	listenerGroup sync.WaitGroup //用于等待所有監(jiān)聽器關閉的同步組
}

/*
	Handler接口定義了HTTP請求處理器的標準行為，任何實現(xiàn)ServerHTTP方法的類型都可以處理HTTP請求。
	Request：包含HTTP請求的所有信息。
	ResponseWriter：用于構造HTTP響應。
*/
type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

/*
	ServeMux是HTTP請求路由器的核心實現(xiàn)，復雜將不同URL路徑的請求分發(fā)給對應的處理函數(shù)。
	其核心作用是通過內部的路由樹（tree）和索引（index）高效匹配請求路徑，同時通過互斥
	鎖（mu）保證并發(fā)安全，并兼容舊版本路由邏輯（mux121）。
*/
type ServeMux struct {
	mu       sync.RWMutex //保護路由表的并發(fā)安全（注冊路由時寫鎖，匹配路由時讀鎖）
	tree     routingNode //路由前綴樹，存儲URL路徑與處理函數(shù)的映射關系，支持高效路徑匹配
	index    routingIndex //路由加速索引，優(yōu)化特定場景的查找性能
	patterns []*pattern  //兼容舊版本的路由模式列表
	mux121   serveMux121 //Go1.21及之前舊版本路由實現(xiàn)
}

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

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

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	if use121 { 
	    //Go1.21及以前版本路由注冊實現(xiàn)
		DefaultServeMux.mux121.handleFunc(pattern, handler)
	} else {
	    //新版本路由注冊實現(xiàn)
		DefaultServeMux.register(pattern, HandlerFunc(handler))
	}
}

func (mux *serveMux121) handleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	...
	
	//將路徑和對應的回調函數(shù)關聯(lián)起來，具體關聯(lián)方法不深究
	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)
	}

	...
	
	//關聯(lián)路徑和對應的回調函數(shù)
	mux.tree.addPattern(pat, handler) 
	mux.index.addPattern(pat)
	mux.patterns = append(mux.patterns, pat)
	return nil
}

//實現(xiàn)了Handler接口
type HandlerFunc func(ResponseWriter, *Request)

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

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) //協(xié)程去響應客戶端連接
	}
}

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處理器實現(xiàn)的處理客戶端請求并響應的方法
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
	...
	
	var h Handler
	if use121 { //舊版本根據(jù)請求進行路由匹配
		h, _ = mux.mux121.findHandler(r)
	} else { //新版本根據(jù)請求進行路由匹配
		h, r.Pattern, r.pat, r.matches = mux.findHandler(r)
	}
    
    /*
    	這里執(zhí)行的是HandlerFunc類型的ServeHTTP方法，因為在注冊路由時都將回調函數(shù)轉換為了HandlerFunc類型。
    	type HandlerFunc func(ResponseWriter, *Request)

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