golang源码分析-启动一个http服务到底发生了什么？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

type PingHandler struct {}

func (h *PingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "pong")
}

func main() {
	http.Handle("/ping", &PingHandler{})
	log.Fatal(http.ListenAndServe(":8080", nil))
}

1
2
3
4
5
6

func main() {
	http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprint(w, "pong")
	})
	log.Fatal(http.ListenAndServe(":8080", nil))
}

1
2
3

func Handle(pattern string, handler Handler)
    Handle registers the handler for the given pattern in the DefaultServeMux.
    The documentation for ServeMux explains how patterns are matched.

1
2
3
4

type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}
    A Handler responds to an HTTP request.

1
2
3
4

func ListenAndServe(addr string, handler Handler) error
    ListenAndServe listens on the TCP network address addr and then calls Serve
    with handler to handle requests on incoming connections. Accepted
    connections are configured to enable TCP keep-alives.

1
2
3
4

func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
    HandleFunc registers the handler function for the given pattern in the
    DefaultServeMux. The documentation for ServeMux explains how patterns are
    matched.

1
2
3
4
5

func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

type ServeMux struct {
	// 读写锁，保证并发安全
	mu    sync.RWMutex
	// 保存路径与处理器之间的映射
	m     map[string]muxEntry
	// 根据路径长度从高到低给处理器排序
	es    []muxEntry // slice of entries sorted from longest to shortest.
	// 是否有一个路径包含hostname
	hosts bool       // whether any patterns contain hostnames
}

type muxEntry struct {
	// 处理器
	h       Handler
	// 路径
	pattern string
}

1
2
3
4

// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

1
2
3
4
5
6
7

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
func (mux *ServeMux) Handle(pattern string, handler Handler) {
	// 并发控制
	mux.mu.Lock()
	defer mux.mu.Unlock()

	// 判断传入路径是否为空
	if pattern == "" {
		panic("http: invalid pattern")
	}
	// 判断传入的处理器是否为空
	if handler == nil {
		panic("http: nil handler")
	}
	// 判断对应的路径之前是否注册过，如果注册过则panic
	if _, exist := mux.m[pattern]; exist {
		panic("http: multiple registrations for " + pattern)
	}

	// 懒加载ServeMux的映射map
	if mux.m == nil {
		mux.m = make(map[string]muxEntry)
	}
	// 给映射map赋值(key: pattern, value: handler)
	e := muxEntry{h: handler, pattern: pattern}
	mux.m[pattern] = e
	if pattern[len(pattern)-1] == '/' {
		// 如果路径的最后一位是/结尾的，则给es字段排序
		mux.es = appendSorted(mux.es, e)
	}

	if pattern[0] != '/' {
		// 如果路径第一个字符不是/开始的，则设置hosts为true
		mux.hosts = true
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ListenAndServe listens on the TCP network address addr and then calls
// Serve with handler to handle requests on incoming connections.
// Accepted connections are configured to enable TCP keep-alives.
//
// The handler is typically nil, in which case the DefaultServeMux is used.
//
// ListenAndServe always returns a non-nil error.
func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	// 将addr和handler保存至Server实例内，并调用Server.ListenAndServe
	return server.ListenAndServe()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func (srv *Server) ListenAndServe() error {
	if srv.shuttingDown() {
		return ErrServerClosed
	}
	addr := srv.Addr
	if addr == "" {
		addr = ":http"
	}
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		return err
	}
	return srv.Serve(ln)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func (srv *Server) Serve(l net.Listener) error {
	// ...略

	var tempDelay time.Duration // how long to sleep on accept failure

	ctx := context.WithValue(baseCtx, ServerContextKey, srv)
	for {
		rw, err := l.Accept()
		// ...略
		c := srv.newConn(rw)
		c.setState(c.rwc, StateNew, runHooks) // before Serve can return
		go c.serve(connCtx)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
	// ...略

	for {
		// 读取请求参数
		w, err := c.readRequest(ctx)

		// ...略
		c.curReq.Store(w)

		// 将conn.server赋给serverHandler并调用serveHTTP进行处理
		serverHandler{c.server}.ServeHTTP(w, w.req)
		// ...略
		// 结束请求
		w.finishRequest()
		// ...略
		c.setState(c.rwc, StateIdle, runHooks)
		c.curReq.Store((*response)(nil))
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	handler := sh.srv.Handler
	if handler == nil {
		// 如果为空, 则赋值为DefaultServeMux
		handler = DefaultServeMux
	}
	// ...略

	// 调用ServeHTTP方法
	handler.ServeHTTP(rw, req)
}

1
2
3
4
5
6
7
8
9

// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
	// ...略
	// 根据请求找到对应的处理器
	h, _ := mux.Handler(r)
	// 调用处理器的ServeHTTP方法处理请求
	h.ServeHTTP(w, r)
}