邹灵彬的博客
文章 标签 分类
邹灵彬的博客

Contents

net/http标准库

 included in 网络编程
   877 words   5 minutes 
Contents

使用net/http库来创建一个http服务：

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

package main

import (
	"fmt"
	"html"
	"net/http"
)

type S struct {}

func (*S) ServeHTTP(w http.ResponseWriter, r *http.Request){

}

func main() {
	http.Handle("/foo", &S{})
	http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "hello, %q",html.EscapeString(r.URL.Path))
	})
	http.ListenAndServe(":8000", nil)
}

通过go doc net/http | grep "^func"命令查询出net/http库所有的对外函数：

 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

func CanonicalHeaderKey(s string) string
func DetectContentType(data []byte) string
func Error(w ResponseWriter, error string, code int)
func Get(url string) (resp *Response, err error)
func Handle(pattern string, handler Handler)
func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
func Head(url string) (resp *Response, err error)
func ListenAndServe(addr string, handler Handler) error
func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error
func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser
func NewRequest(method, url string, body io.Reader) (*Request, error)
func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error)
func NotFound(w ResponseWriter, r *Request)
func ParseHTTPVersion(vers string) (major, minor int, ok bool)
func ParseTime(text string) (t time.Time, err error)
func Post(url, contentType string, body io.Reader) (resp *Response, err error)
func PostForm(url string, data url.Values) (resp *Response, err error)
func ProxyFromEnvironment(req *Request) (*url.URL, error)
func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error)
func ReadRequest(b *bufio.Reader) (*Request, error)
func ReadResponse(r *bufio.Reader, req *Request) (*Response, error)
func Redirect(w ResponseWriter, r *Request, url string, code int)
func Serve(l net.Listener, handler Handler) error
func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, ...)
func ServeFile(w ResponseWriter, r *Request, name string)
func ServeTLS(l net.Listener, handler Handler, certFile, keyFile string) error
func SetCookie(w ResponseWriter, cookie *Cookie)
func StatusText(code int) string

去掉New和Set开头的函数，剩下的函数可以分为这三大类：

  • 为服务端提供创建HTTP服务的函数，名字中一般包含Serve；
  • 为客户端提供调用HTTP服务的类库，以http的method同名，比如Get，Post，Head等；
  • 提供代理的一些函数，比如ProxyURL,ProxyFromEnvironment等。

先分析Serve函数：

1
2
3
4
5
6

func Serve(l net.Listener, handler Handler) error
func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, ...)
func ServeFile(w ResponseWriter, r *Request, name string)
func ServeTLS(l net.Listener, handler Handler, certFile, keyFile string) error
func ListenAndServe(addr string, handler Handler) error
func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error

先从启动服务的http.ListenAndServe函数开始：

1
2
3
4

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

通过示例代码和http.ListenAndServe源码可以看到，该方法创建一个Server结构，调用Server.ListenAndServe对外提供服务。接下来再看Server.ListenAdnServer源码：

 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)
}

Server.ListenAdnServer方法先定义了监听信息，再调用Serve方法。在Serve方法中，用一个for循环，通过l.Accept不断接收从客户端传来的请求连接。当接收到一个新的请求时，通过srv.Conn 创建一个连接结构(http.conn)，并创建一个goroutine去处理这个请求。

 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
38
39
40
41
42
43
44
45
46
47
48

func (srv *Server) Serve(l net.Listener) error {
	if fn := testHookServerServe; fn != nil {
		fn(srv, l) // call hook with unwrapped listener
	}

	origListener := l
	l = &onceCloseListener{Listener: l}
	defer l.Close()

	if err := srv.setupHTTP2_Serve(); err != nil {
		return err
	}

	if !srv.trackListener(&l, true) {
		return ErrServerClosed
	}
	defer srv.trackListener(&l, false)

	baseCtx := context.Background()
	if srv.BaseContext != nil {
		baseCtx = srv.BaseContext(origListener)
		if baseCtx == nil {
			panic("BaseContext returned a nil context")
		}
	}

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

	ctx := context.WithValue(baseCtx, ServerContextKey, srv)
	for {
		rw, err := l.Accept()
		if err != nil {
		    ...
		    ...
		}
		connCtx := ctx
		if cc := srv.ConnContext; cc != nil {
			connCtx = cc(connCtx, rw)
			if connCtx == nil {
				panic("ConnContext returned nil")
			}
		}
		tempDelay = 0
		c := srv.newConn(rw)
		c.setState(c.rwc, StateNew, runHooks) // before Serve can return
		go c.serve(connCtx)
	}
}

从c.serve(connCtx)开始就是单个连接的逻辑了。c.serve函数先判断本次请求时候需要升级为https，然后创建都文本的reader和写文本的buffer，再进一步读取本次请求数据，然后调用serverHandler{c.server}.ServeHTTP(w, w.req)来处理这次请求。

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

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 serverHandler struct {
	srv *Server
}

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	handler := sh.srv.Handler
	if handler == nil {
		handler = DefaultServeMux
	}
	if req.RequestURI == "*" && req.Method == "OPTIONS" {
		handler = globalOptionsHandler{}
	}
	handler.ServeHTTP(rw, req)
}

DefaultServeMux是一个ServeMux结构的实例，是一个多路复用器。在最前面调用http.ListenAndServe()时，如果没有传入第二个参数hanler，则handler = DefaultServeMux。 启动http服务的时候，可以使用http.HandleFunc()来指定路由和处理函数。

 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
38

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

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

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")
    }
    if _, exist := mux.m[pattern]; exist {
        panic("http: multiple registrations for " + pattern)
    }

    if mux.m == nil {
        mux.m = make(map[string]muxEntry)
    }
    e := muxEntry{h: handler, pattern: pattern}
    mux.m[pattern] = e
    if pattern[len(pattern)-1] == '/' {
        mux.es = appendSorted(mux.es, e)
    }

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

通过源码可以看到，最终的调用是ServeMux.Handle方法。ServeMux.Handle是一个非常简单的map实现，key是路径(pattern)，value是这个pattern对应的处理函数。它是通过mux.match(path)寻找对应的Handler， 也就是DefaultServeMux内部的map中直接根据key寻找到value的。

总结

抛去关于HTTPS的处理，具体的刘城逻辑就是：

  • 创建http服务是通过创建一个Server结构完成的；
  • Server在for循环里不断监听每一个连接；
  • 每个连接默认开启一个goroutine去处理；
  • Server如果没有设置处理函数Handler，默认使用DefaultServeMux处理请求；
  • DefaultServeMux是使用map来存储和查找路由规则。
https://s3.bmp.ovh/imgs/2021/10/58a48ae3bce26124.png
Updated on 2021-08-03
 Go, 标准库, 网络编程
Back | Home