简单服务器 Demo
在 Go 编写一个服务器非常简单：
func main() {
http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
writer.Write([]byte("hello, world!"))
})
http.ListenAndServe(":8080", nil)
}
之后便可以访问：
~ curl localhost:8080/
hello, world!
也可以用自定义类型实现 http.Handler 接口的方式：
func main() {
helloStr := "hello, world!"
http.Handle("/hello", helloHandler(helloStr)) // 用 helloStr 处理 /hello 请求
http.ListenAndServe(":8080", nil)
}
type helloHandler string
// Implement http.Handler.
func (h helloHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
writer.Write([]byte(h))
}
上述代码中，向 http.Handle 方法传入了请求路径和相应处理请求的 handler，请求到达时服务器会根据请求路径找到相应的 handler 处理请求。
http.ResponseWriter 接口
ResponseWriter 接口用于让 handler 构建一个 http 响应，其方法如下：
// 返回将要被 WriteHeader 发送的响应头。
Header() Header
// 将数据写到 Http 连接中。
// 如果调用该方法时 WriteHeader 还未被调用，Write 将先调用 WriteHeader(http.StatusOK)。
Write([]byte) (int, error)
// 该方法发送一个包含状态码 statusCode 的 HTTP 响应头
WriteHeader(statusCode int)
Header()
Header 代表了 HTTP 首部中的键值对，其实际是一个哈希表：
type Header map[string][]string
Header 包含的方法主要是对响应头键值对的增删改查，以 Add 方法为例：
// 将键值对添加到响应头中。其中键是大小写不敏感的。
func (h Header) Add(key, value string) {
textproto.MIMEHeader(h).Add(key, value)
}
它将 Header 转为 MIMEHeader 类型，实际调用了 MIMEHeader 的 Add 方法：
func (h MIMEHeader) Add(key, value string) {
// 将 MIME 头部的键值转换为规范格式，如 "accept-encoding" 转换为 "Accept-Encoding"。
key = CanonicalMIMEHeaderKey(key)
h[key] = append(h[key], value)
}
Write([]byte)
该方法将数据写到 HTTP 连接中。
WriteHeader(statusCode int)
该方法发送一个包含状态码 statusCode 的 HTTP 响应头。
于 IANA 登记的状态码位于 http/status.go 中，这里仅列出几个常见的状态码：
package http
// HTTP status codes as registered with IANA.
const (
StatusContinue = 100 // RFC 7231, 6.2.1
StatusSwitchingProtocols = 101 // RFC 7231, 6.2.2
StatusProcessing = 102 // RFC 2518, 10.1
StatusEarlyHints = 103 // RFC 8297
StatusOK = 200 // RFC 7231, 6.3.1
StatusCreated = 201 // RFC 7231, 6.3.2
StatusAccepted = 202 // RFC 7231, 6.3.3
StatusNonAuthoritativeInfo = 203 // RFC 7231, 6.3.4
StatusNoContent = 204 // RFC 7231, 6.3.5
StatusMultipleChoices = 300 // RFC 7231, 6.4.1
StatusMovedPermanently = 301 // RFC 7231, 6.4.2
StatusFound = 302 // RFC 7231, 6.4.3
StatusSeeOther = 303 // RFC 7231, 6.4.4
StatusNotModified = 304 // RFC 7232, 4.1
StatusBadRequest = 400 // RFC 7231, 6.5.1
StatusUnauthorized = 401 // RFC 7235, 3.1
StatusPaymentRequired = 402 // RFC 7231, 6.5.2
StatusForbidden = 403 // RFC 7231, 6.5.3
StatusNotFound = 404 // RFC 7231, 6.5.4
StatusMethodNotAllowed = 405 // RFC 7231, 6.5.5
StatusNotAcceptable = 406 // RFC 7231, 6.5.6
StatusInternalServerError = 500 // RFC 7231, 6.6.1
StatusNotImplemented = 501 // RFC 7231, 6.6.2
StatusBadGateway = 502 // RFC 7231, 6.6.3
...
)
var statusText = map[int]string{
StatusContinue: "Continue",
StatusSwitchingProtocols: "Switching Protocols",
StatusProcessing: "Processing",
StatusEarlyHints: "Early Hints",
StatusOK: "OK",
StatusCreated: "Created",
StatusAccepted: "Accepted",
StatusNonAuthoritativeInfo: "Non-Authoritative Information",
StatusNoContent: "No Content",
StatusMultipleChoices: "Multiple Choices",
StatusMovedPermanently: "Moved Permanently",
StatusFound: "Found",
StatusSeeOther: "See Other",
StatusNotModified: "Not Modified",
StatusBadRequest: "Bad Request",
StatusUnauthorized: "Unauthorized",
StatusPaymentRequired: "Payment Required",
StatusForbidden: "Forbidden",
StatusNotFound: "Not Found",
StatusMethodNotAllowed: "Method Not Allowed",
StatusNotAcceptable: "Not Acceptable",
StatusInternalServerError: "Internal Server Error",
StatusNotImplemented: "Not Implemented",
StatusBadGateway: "Bad Gateway",
...
}
// 根据状态码获取相应的消息。
func StatusText(code int) string {
return statusText[code]
}
response 结构体
在 http 包的服务器实现中，传给 handler 的 ResponseWriter 的实际类型是 http 包下的 response ，换言之，response 实现了 ResponseWriter 接口。其结构如下：
// response 代表服务器的 HTTP 响应.
type Response struct {
Status string // 例如"200 OK"
StatusCode int // 例如200
Proto string // 例如"HTTP/1.0"
ProtoMajor int // 例如1
ProtoMinor int // 例如0
// Header保管头域的键值对。
// 如果回复中有多个头的键相同，Header中保存为该键对应用逗号分隔串联起来的这些头的值
// （参见RFC 2616 Section 4.2）
// 被本结构体中的其他字段复制保管的头（如ContentLength）会从Header中删掉。
//
// Header中的键都是规范化的，参见CanonicalHeaderKey函数
Header Header
// Body代表回复的主体。
// Client类型和Transport类型会保证Body字段总是非nil的，即使回复没有主体或主体长度为0。
// 关闭主体是调用者的责任。
// 如果服务端采用"chunked"传输编码发送的回复，Body字段会自动进行解码。
Body io.ReadCloser
// ContentLength记录相关内容的长度。
// 其值为-1表示长度未知（采用chunked传输编码）
// 除非对应的Request.Method是"HEAD"，其值>=0表示可以从Body读取的字节数
ContentLength int64
// TransferEncoding按从最外到最里的顺序列出传输编码，空切片表示"identity"编码。
TransferEncoding []string
// Close记录头域是否指定应在读取完主体后关闭连接。（即Connection头）
// 该值是给客户端的建议，Response.Write方法的ReadResponse函数都不会关闭连接。
Close bool
// Trailer字段保存和头域相同格式的trailer键值对，和Header字段相同类型
Trailer Header
// Request是用来获取此回复的请求
// Request的Body字段是nil（因为已经被用掉了）
// 这个字段是被Client类型发出请求并获得回复后填充的
Request *Request
// TLS包含接收到该回复的TLS连接的信息。 对未加密的回复，本字段为nil。
// 返回的指针是被（同一TLS连接接收到的）回复共享的，不应被修改。
TLS *tls.ConnectionState
}
Header()
Header 方法将 handlerHeader 拷贝到 chunkWriter 的 header 中，然后将 handlerHeader 返回。
func (w *response) Header() Header {
if w.cw.header == nil && w.wroteHeader && !w.cw.wroteHeader {
// 在逻辑写和物理写之间访问响应头，需要对逻辑写入的状态进行快照。
// 即若 w.cw 中的 header 并未设置，则拷贝一份放到 w.cw 中。
// response 的 WriteHeader 方法会将 handlerHeader 拷贝到 w.cw 中。
// 由于 w.cw 中的 header 仅包内可见，且没有修改方法，
// 后续 w.cw.header 将免于再被修改。
w.cw.header = w.handlerHeader.Clone()
}
w.calledHeader = true // 标记 handler 通过 Header 方法访问了 handlerHeader。
return w.handlerHeader
}
Write([]byte)
func (w *response) Write(data []byte) (n int, err error) {
return w.write(len(data), data, "")
}
调用了其 write 方法：
// either dataB or dataS is non-zero.
func (w *response) write(lenData int, dataB []byte, dataS string) (n int, err error) {
// 该连接是否已经被劫持
// 因为被劫持的连接交由相应的 handler 接管，返回 ErrHijacked
if w.conn.hijacked() {
if lenData > 0 {
caller := relevantCaller()
w.conn.server.logf("http: response.Write on hijacked connection from %s (%s:%d)", caller.Function, path.Base(caller.File), caller.Line)
}
return 0, ErrHijacked
}
// canWriteContinue 指示是否能将 100 Continue 写到连接中。
if w.canWriteContinue.isSet() {
// 请求体 reader 想要写出 100 Continue 但还未写出。
// 告诉它不要写出。持有 writeContinueMu 是为了确保当前没有在写出数据。
w.writeContinueMu.Lock()
w.canWriteContinue.setFalse()
w.writeContinueMu.Unlock()
}
// 如果还没写入响应码，则将 StatusOK 写入。
if !w.wroteHeader {
w.WriteHeader(StatusOK)
}
if lenData == 0 {
return 0, nil
}
// 根据状态码判断是否允许写响应体。
// 当状态码为 100~199, 204, 304 时不允许有响应体。
if !w.bodyAllowed() {
return 0, ErrBodyNotAllowed
}
w.written += int64(lenData) // 即使最终没有写出，仍计入 written
// 如果写出的数据大于响应头 Content-Length，则不写出。
if w.contentLength != -1 && w.written > w.contentLength {
return 0, ErrContentLength
}
if dataB != nil {
return w.w.Write(dataB) // 调用 response 的 bufio.Writer 写入数据。
} else {
return w.w.WriteString(dataS)
}
}
WriteHeader(statusCode int)
func (w *response) WriteHeader(code int) {
// 如果连接被劫持，即连接已被一个 handler 接管，则不写入头部。
if w.conn.hijacked() {
caller := relevantCaller()
w.conn.server.logf("http: response.WriteHeader on hijacked connection from %s (%s:%d)", caller.Function, path.Base(caller.File), caller.Line)
return
}
// 如果已经写过头部，则不再重复写入。
if w.wroteHeader {
caller := relevantCaller() // relevantCaller 找到此方法的调用者
w.conn.server.logf("http: superfluous response.WriteHeader call from %s (%s:%d)", caller.Function, path.Base(caller.File), caller.Line)
return
}
checkWriteHeaderCode(code) // 100 <= code <= 999?
w.wroteHeader = true
w.status = code
if w.calledHeader && w.cw.header == nil {
w.cw.header = w.handlerHeader.Clone()
}
// 如果设置了 Content-Length，则将该 header 的值放到 response.contentLength 中
if cl := w.handlerHeader.get("Content-Length"); cl != "" {
v, err := strconv.ParseInt(cl, 10, 64)
if err == nil && v >= 0 {
w.contentLength = v
} else {
w.conn.server.logf("http: invalid Content-Length of %q", cl)
w.handlerHeader.Del("Content-Length")
}
}
}
http.Request
与 http.ResponseWriter 不同的是，http.Request 是一个结构体而不是接口。
// Request 代表了一个服务器收到的请求，或一个 client 将要发出的请求。
type Request struct {
// Method指定HTTP方法（GET、POST、PUT等）。对客户端，""代表GET。
Method string
// URL在服务端表示被请求的URI，在客户端表示要访问的URL。
//
// 在服务端，URL字段是解析请求行的URI（保存在RequestURI字段）得到的，
// 对大多数请求来说，除了Path和RawQuery之外的字段都是空字符串。
// （参见RFC 2616, Section 5.1.2）
//
// 在客户端，URL的Host字段指定了要连接的服务器，
// 而Request的Host字段（可选地）指定要发送的HTTP请求的Host头的值。
URL *url.URL
// 接收到的请求的协议版本。本包生产的Request总是使用HTTP/1.1
Proto string // "HTTP/1.0"
ProtoMajor int // 1
ProtoMinor int // 0
// Header字段用来表示HTTP请求的头域。如果头域（多行键值对格式）为：
// accept-encoding: gzip, deflate
// Accept-Language: en-us
// Connection: keep-alive
// 则：
// Header = map[string][]string{
// "Accept-Encoding": {"gzip, deflate"},
// "Accept-Language": {"en-us"},
// "Connection": {"keep-alive"},
// }
// HTTP规定头域的键名（头名）是大小写敏感的，请求的解析器通过规范化头域的键名来实现这点。
// 在客户端的请求，可能会被自动添加或重写Header中的特定的头，参见Request.Write方法。
Header Header
// Body是请求的主体。
//
// 在客户端，如果Body是nil表示该请求没有主体买入GET请求。
// Client的Transport字段会负责调用Body的Close方法。
//
// 在服务端，Body字段总是非nil的；但在没有主体时，读取Body会立刻返回EOF。
// Server会关闭请求的主体，ServeHTTP处理器不需要关闭Body字段。
Body io.ReadCloser
// ContentLength记录相关内容的长度。
// 如果为-1，表示长度未知，如果>=0，表示可以从Body字段读取ContentLength字节数据。
// 在客户端，如果Body非nil而该字段为0，表示不知道Body的长度。
ContentLength int64
// TransferEncoding按从最外到最里的顺序列出传输编码，空切片表示"identity"编码。
// 本字段一般会被忽略。当发送或接受请求时，会自动添加或移除"chunked"传输编码。
TransferEncoding []string
// Close在服务端指定是否在回复请求后关闭连接，在客户端指定是否在发送请求后关闭连接。
Close bool
// 在服务端，Host指定URL会在其上寻找资源的主机。
// 根据RFC 2616，该值可以是Host头的值，或者URL自身提供的主机名。
// Host的格式可以是"host:port"。
//
// 在客户端，请求的Host字段（可选地）用来重写请求的Host头。
// 如过该字段为""，Request.Write方法会使用URL字段的Host。
Host string
// Form是解析好的表单数据，包括URL字段的query参数和POST或PUT的表单数据。
// 本字段只有在调用ParseForm后才有效。在客户端，会忽略请求中的本字段而使用Body替代。
Form url.Values
// PostForm是解析好的POST或PUT的表单数据。
// 本字段只有在调用ParseForm后才有效。在客户端，会忽略请求中的本字段而使用Body替代。
PostForm url.Values
// MultipartForm是解析好的多部件表单，包括上传的文件。
// 本字段只有在调用ParseMultipartForm后才有效。
// 在客户端，会忽略请求中的本字段而使用Body替代。
MultipartForm *multipart.Form
// Trailer指定了会在请求主体之后发送的额外的头域。
//
// 在服务端，Trailer字段必须初始化为只有trailer键，所有键都对应nil值。
// （客户端会声明哪些trailer会发送）
// 在处理器从Body读取时，不能使用本字段。
// 在从Body的读取返回EOF后，Trailer字段会被更新完毕并包含非nil的值。
// （如果客户端发送了这些键值对），此时才可以访问本字段。
//
// 在客户端，Trail必须初始化为一个包含将要发送的键值对的映射。（值可以是nil或其终值）
// ContentLength字段必须是0或-1，以启用"chunked"传输编码发送请求。
// 在开始发送请求后，Trailer可以在读取请求主体期间被修改，
// 一旦请求主体返回EOF，调用者就不可再修改Trailer。
//
// 很少有HTTP客户端、服务端或代理支持HTTP trailer。
Trailer Header
// RemoteAddr允许HTTP服务器和其他软件记录该请求的来源地址，一般用于日志。
// 本字段不是ReadRequest函数填写的，也没有定义格式。
// 本包的HTTP服务器会在调用处理器之前设置RemoteAddr为"IP:port"格式的地址。
// 客户端会忽略请求中的RemoteAddr字段。
RemoteAddr string
// RequestURI是被客户端发送到服务端的请求的请求行中未修改的请求URI
// （参见RFC 2616, Section 5.1）
// 一般应使用URI字段，在客户端设置请求的本字段会导致错误。
RequestURI string
// TLS字段允许HTTP服务器和其他软件记录接收到该请求的TLS连接的信息
// 本字段不是ReadRequest函数填写的。
// 对启用了TLS的连接，本包的HTTP服务器会在调用处理器之前设置TLS字段，否则将设TLS为nil。
// 客户端会忽略请求中的TLS字段。
TLS *tls.ConnectionState
}
http.Handle
在声明对一个路径的处理器时，调用了：
http.Handle("/", helloHandler(handler))
其源码如下：
// Handle 函数对给定路径的处理器在 DefaultServeMux 中进行注册。
func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
该函数在 DefaultServeMux 中对路径和处理器进行注册，该函数将 pattern 和 handler 传给了 DefaultServeMux 的 Handle 方法。
ServeMux 是 HTTP 请求的多路转接器（multiplexer）。它会将每一个接收的请求的 URL 与一个注册模式的列表进行匹配，并调用和 URL 最匹配的模式的处理器。
DefaultServeMux.Handle 实际上将模式放到一个哈希表中；如果路径以 '/' 结尾，则额外将其放到一个根据路径长度由长到短排序的数组中。例如，在匹配时如果不存在 /greetings/meet 路径的处理器，则依次尝试查找 /greetings/ 和 / 路径的处理器。
// Handle 为一个模式注册处理器。
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")
}
// m 是由 pattern 到 muxEntry 的映射，若已经存在则 panic。
// muxEntry 是由处理器 Handler 和 pattern 组成的结构体。
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
// 如果路径以 '/' 结尾，则将新的 muxEntry 插入到 es 中
if pattern[len(pattern)-1] == '/' {
mux.es = appendSorted(mux.es, e)
}
if pattern[0] != '/' {
mux.hosts = true // hosts：是否有模式指示了主机名
}
}
例如，以下三个 handler 分别处理三个路径的请求：
func main() {
rootHandler := "hello"
http.Handle("/", helloHandler(rootHandler))
hiHandler := "hi"
http.Handle("/hi", helloHandler(hiHandler))
byeHandler := "bye"
http.Handle("/bye", helloHandler(byeHandler))
http.ListenAndServe(":8080", nil)
}
得到 mux.m 的内容如下:
http.ListenAndServe
地址的绑定和监听
在添加完各 handler 后，通过调用 http.ListenAndServe 函数开启服务器：
http.ListenAndServe(":8080", nil)
其源码如下：
// ListenAndServe 监听给出的 TCP 地址 addr，然后对到来的连接调用 Serve 方法，
// Serve 方法再利用入参 handler 映射来自该连接的请求。
// 入参 handler 用于对路径进行映射，如果设置为 nil，则 DefaultServeMux 将用于对路径进行映射。
func ListenAndServe(addr string, handler Handler) error {
server := &Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}
ListenAndServe 函数利用 TCP 地址 addr 和地址映射 handler 创建了一个 Server，然后调用了其 ListenAndServe 方法。
// ListenAndServe 方法监听 TCP 地址然后调用 Serve 方法处理到来的连接。
// 接受的连接被配置为开启 TCP 保活。
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)
}
net.Listen 源码如下：
// Listen("tcp", ":8080")
func Listen(network, address string) (Listener, error) {
var lc ListenConfig
return lc.Listen(context.Background(), network, address)
}
其声明了一个 ListenConfig 后 调用其 Listen 方法：
// Listen announces on the local network address.、
func (lc *ListenConfig) Listen(ctx context.Context, network, address string) (Listener, error) {
addrs, err := DefaultResolver.resolveAddrList(ctx, "listen", network, address, nil) // 根据动作、协议、地址等解析返回 addrList 结构
if err != nil {
return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: nil, Err: err}
}
sl := &sysListener{
ListenConfig: *lc,
network: network,
address: address,
}
var l Listener
la := addrs.first(isIPv4) // 找到第一个包含 IPv4 地址的 Addr
switch la := la.(type) {
case *TCPAddr:
l, err = sl.listenTCP(ctx, la) // 监听 TCP
case *UnixAddr:
l, err = sl.listenUnix(ctx, la)
default:
return nil, &OpError{Op: "listen", Net: sl.network, Source: nil, Addr: la, Err: &AddrError{Err: "unexpected address type", Addr: address}}
}
if err != nil {
return nil, &OpError{Op: "listen", Net: sl.network, Source: nil, Addr: la, Err: err} // l is non-nil interface containing nil pointer
}
return l, nil
}
上述方法利用监听配置、网络协议类型、地址声明了一个 sysListener，然后调用了其 listenTCP 方法得到 Listener：
// 调用了 internetSocket 创建套接字，将其封装为一个 TCPListener 后返回。
func (sl *sysListener) listenTCP(ctx context.Context, laddr *TCPAddr) (*TCPListener, error) {
fd, err := internetSocket(ctx, sl.network, laddr, nil, syscall.SOCK_STREAM, 0, "listen", sl.ListenConfig.Control)
if err != nil {
return nil, err
}
return &TCPListener{fd: fd, lc: sl.ListenConfig}, nil
}
该方法调用了 internetSocket 函数创建一个套接字，sotype 即 socket 的类型，其传入的 sotype 参数为 syscall.SOCK_STREAM，SOCK_STREAM 提供面向连接的稳定数据传输，即TCP协议。internetSocket 源码如下：
// internetSocket 处理了一些特殊情况然后调用了 socket 创建套接字并返回之。
func internetSocket(ctx context.Context, net string, laddr, raddr sockaddr, sotype, proto int, mode string, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error) {
// 如果是通配符地址
if (runtime.GOOS == "aix" || runtime.GOOS == "windows" || runtime.GOOS == "openbsd") && mode == "dial" && raddr.isWildcard() {
// 将零地址映射为本地系统地址（127.0.0.1 或 ::1）
raddr = raddr.toLocal(net)
}
family, ipv6only := favoriteAddrFamily(net, laddr, raddr, mode) // 返回 syscall.AF_INET6，即 TCP/IP – IPv6 协议簇
return socket(ctx, net, family, sotype, proto, ipv6only, laddr, raddr, ctrlFn)
}
socket 源码如下：
// socket 函数返回一个网络文件描述符，该描述符可以使用网络轮询器 poller 进行异步 I/O
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error) {
s, err := sysSocket(family, sotype, proto) // 返回 s 即描述符的编号
...
}
socket 调用了 sysSocket 获得了套接字的描述符：
// 包装了 socket 系统调用，并将返回的文件描述符标记为非阻塞的，并在 exec 系统调用时将其关闭。
func sysSocket(family, sotype, proto int) (int, error) {
syscall.ForkLock.RLock()
s, err := socketFunc(family, sotype, proto) // 调用 socketFunc 取得了描述符
if err == nil {
syscall.CloseOnExec(s)
}
syscall.ForkLock.RUnlock()
if err != nil {
return -1, os.NewSyscallError("socket", err)
}
if err = syscall.SetNonblock(s, true); err != nil {
poll.CloseFunc(s)
return -1, os.NewSyscallError("setnonblock", err)
}
return s, nil
}
sysSocket 调用 socketFunc 取得了描述符。socketFunc 其实是 syscall.Socket：
var (
...
// socket 系统调用的占位符
socketFunc func(int, int, int) (int, error) = syscall.Socket
...
)
其源码如下：
// 检查是否创建 AF_INET6 协议簇但套接字禁用了 IPv6.
func Socket(domain, typ, proto int) (fd int, err error) {
if domain == AF_INET6 && SocketDisableIPv6 {
return -1, EAFNOSUPPORT
}
// 调用 socket 创建套接字
fd, err = socket(domain, typ, proto)
return
}
socket 函数源码如下，该函数真正进行了 socket 系统调用：
func socket(domain int, typ int, proto int) (fd int, err error) {
r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto)) // libc_socket_trampoline 是真正的 socket 系统调用
fd = int(r0)
if e1 != 0 {
err = errnoErr(e1)
}
return
}
socket 函数一路将描述符返回，直至 sock_posix.go 下的 socket 函数：
// socket 函数返回一个网络文件描述符，该描述符可以使用网络轮询器 poller 进行异步 I/O
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error) {
s, err := sysSocket(family, sotype, proto) // 返回 s 即描述符的编号
if err != nil {
return nil, err
}
// 设置默认套接字选项。
if err = setDefaultSockopts(s, family, sotype, ipv6only); err != nil {
// 如果设置失败，则调用 close 系统调用关闭文件描述符。
poll.CloseFunc(s)
return nil, err
}
// 利用套接字编号、协议簇、协议、网络类型创建一个描述符。
// newFD(s, syscall.AF_INET6, syscall.SOCK_STREAM, "tcp")
if fd, err = newFD(s, family, sotype, net); err != nil {
// 如果创建失败，则调用 close 系统调用关闭文件描述符。
poll.CloseFunc(s)
return nil, err
}
// laddr 和 raddr 意即 local address 和 remote address
// 当本地地址不为空且远程地址为空时
if laddr != nil && raddr == nil {
switch sotype {
case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET:
// listenStream 对描述符进行了设置、将描述符与监听地址进行了绑定、开启对地址的监听。
// 另外，backlog 是保存客户端请求的队列长度。
if err := fd.listenStream(laddr, listenerBacklog(), ctrlFn); err != nil {
fd.Close()
return nil, err
}
return fd, nil
case syscall.SOCK_DGRAM:
if err := fd.listenDatagram(laddr, ctrlFn); err != nil {
fd.Close()
return nil, err
}
return fd, nil
}
}
if err := fd.dial(ctx, laddr, raddr, ctrlFn); err != nil {
fd.Close()
return nil, err
}
return fd, nil
}
socket 函数利用调用 sysSocket 获取的文件描述符创建了一个网络文件句柄 fd，之后调用该网络文件句柄的 listenStream 方法开始监听到来的数据流：
func (fd *netFD) listenStream(laddr sockaddr, backlog int, ctrlFn func(string, string, syscall.RawConn) error) error {
var err error
// 为监听套接字设置默认选项
if err = setDefaultListenerSockopts(fd.pfd.Sysfd); err != nil {
return err
}
var lsa syscall.Sockaddr
if lsa, err = laddr.sockaddr(fd.family); err != nil {
return err
}
// 如果传入了 ctrlFn，则先调用一下
if ctrlFn != nil {
c, err := newRawConn(fd)
if err != nil {
return err
}
if err := ctrlFn(fd.ctrlNetwork(), laddr.String(), c); err != nil {
return err
}
}
// 将句柄与地址绑定，即 bind 系统调用
if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
return os.NewSyscallError("bind", err)
}
// 开启监听，listenFunc 实际是 syscall.Listen，即 listen 系统调用
if err = listenFunc(fd.pfd.Sysfd, backlog); err != nil {
return os.NewSyscallError("listen", err)
}
// 对句柄进行初始化
if err = fd.init(); err != nil {
return err
}
// Getsockname 通过 getsockname 系统调用获取一个套接字的名字
// 其利用套接字描述符获取该套接字的名字
// 对于 TCP 连接的情况，如果不进行 bind 指定 IP 和端口，那么调用 connect 连接成功后，
// 使用 getsockname 可以正确获得当前正在通信的 socket 的 IP 和端口地址。
// 这里通过 Getsockname 和 setAddr 方法设置了 fd 的地址。
lsa, _ = syscall.Getsockname(fd.pfd.Sysfd)
fd.setAddr(fd.addrFunc()(lsa), nil)
return nil
}
至此，ListenAndServe 完成了套接字的创建，开始对指定的 TCP 地址进行监听。
连接的接收和请求的映射
回到 ListenAndServe 方法：
// ListenAndServe 方法监听 TCP 地址然后调用 Serve 方法处理到来的连接。
// 接受的连接被配置为开启 TCP keep-alive。
func (srv *Server) ListenAndServe() error {
...
ln, err := net.Listen("tcp", addr) // 由上文可知这里开启了对 TCP 地址的监听，该函数返回了一个用于监听面向流协议的 Listener.
if err != nil {
return err
}
return srv.Serve(ln) // Serve 方法接收到来的连接并处理请求
}
在开启了对 TCP 地址的绑定和监听后，调用了 Server 的 Serve 方法，其源码如下：
// Serve 方法从 listener 中接收到来的连接，并为每个连接创建一个 goroutine 处理请求
// 负责服务的 goroutine 读取请求并调用 srv.Handler 回复请求。
func (srv *Server) Serve(l net.Listener) error {
...
// 从该连接不断地读取请求
for {
rw, err := l.Accept() // 调用 Accept 方法接收到来的连接，返回的 rw 是 Conn 对象，代表了一个面向流的连接
if err != nil {
select {
case <-srv.getDoneChan():
return ErrServerClosed
default:
}
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
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) // 开启新的 goroutine 处理请求
}
}
Listener 的 Accept 方法监听并返回了到来的连接。之后调用 src.newConn 封装为 conn （一个 conn 代表服务器侧的连接），设置一下连接的状态、运行一下钩子函数，之后新开启了一个 goroutine 运行该连接的 serve 方法，并将相应的 context 传入。
// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
c.remoteAddr = c.rwc.RemoteAddr().String() // 远程地址的 IP 及端口号
ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())
defer func() {
// 从 panic 中恢复，即使具体某个 handler 处理请求时发生 panic，也不会导致整个服务器退出
if err := recover(); err != nil && err != ErrAbortHandler {
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)]
c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)
}
// 如果连接没有被劫持，则关闭之，并将状态设置为关闭，运行一下钩子函数。
if !c.hijacked() {
c.close()
c.setState(c.rwc, StateClosed, runHooks)
}
}()
if tlsConn, ok := c.rwc.(*tls.Conn); ok {
...
}
// HTTP/1.x from here on.
// 创建了一个子 context
ctx, cancelCtx := context.WithCancel(ctx)
c.cancelCtx = cancelCtx
defer cancelCtx() // 方法返回前取消任务
c.r = &connReader{conn: c}
c.bufr = newBufioReader(c.r)
c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)
for {
w, err := c.readRequest(ctx) // 从连接中读取下一个请求
if c.r.remain != c.server.initialReadLimitSize() {
// 将状态设置为活跃。
c.setState(c.rwc, StateActive, runHooks)
}
if err != nil {
// 错误处理，如请求太大、请求使用了不支持的编码类型等。
...
}
// Expect 100 Continue support
req := w.req
if req.expectsContinue() {
if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
// 包装请求体的 reader: req.Body
// 将请求体 req.Body 传给 expectContinueReader，可以让 expectContinueReader 写出 100 Cotinue
req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
// 指示可以将 100 Continue 写出。
// 实际 100 Continue 由 expectContinueReader 写出
w.canWriteContinue.setTrue()
}
} else if req.Header.get("Expect") != "" {
w.sendExpectationFailed()
return
}
c.curReq.Store(w)
if requestBodyRemains(req.Body) {
registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)
} else {
w.conn.r.startBackgroundRead()
}
// 尽管 HTTP 管线可以同时处理多个请求，这里并没有实现此功能，而是就在此 goroutine 运行了请求处理器。
// ServeHTTP 完成了地址到处理器的映射，并调用处理器进行处理。
serverHandler{c.server}.ServeHTTP(w, w.req)
// 后续进行了一些收尾工作
...
}
}
ServeHTTP 完成了地址到处理器的映射，并调用处理器进行处理。其实现如下：
// serverHandler 找到映射请求的 handler 并将请求转发给它。
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
handler := sh.srv.Handler // 该 Handler 负责映射请求。
// 如果没有设置 handler，则用默认的路由规则。
if handler == nil {
handler = DefaultServeMux
}
// 如果要处理的是获取选项的请求，则用 globalOptionsHandler 处理请求。
if req.RequestURI == "*" && req.Method == "OPTIONS" {
handler = globalOptionsHandler{}
}
...
handler.ServeHTTP(rw, req) // 利用该 handler 映射请求
}
如果在 main 函数中调用 ListenAndServe 时没有指定路径映射的 handler，则默认使用 DefaultServeMux，其 ServeHTTP 方法如下：
// ServeHTTP 将请求分发到跟请求 URL 最为匹配的模式的处理器
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
// 如果 URI 为 '*'，则直接关闭连接并返回。
if r.RequestURI == "*" {
if r.ProtoAtLeast(1, 1) {
w.Header().Set("Connection", "close")
}
w.WriteHeader(StatusBadRequest)
return
}
h, _ := mux.Handler(r) // 获得处理器
h.ServeHTTP(w, r) // 处理请求
}
我们看 DefaultServeMux 的 Handler 方法是如何分发请求的：
// Handler 返回给出路径的处理器，它参考了请求的方法、请求主机名、URL。
// 如果 path 不是在标准形式下，返回的将是一个内部生成的 handler，
// 该 handler 将请求重定向到标准形式的路径下。
// 如果主机名包含一个端口号，他在匹配 handler 时将被忽略。
// 如果没有符合请求路径的 handler，将返回一个 `page not found' handler。
// 该 Handler 方法主要对请求路径进行标准化，随后调用其 handler 方法进行映射。
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
// CONNECT requests are not canonicalized.
if r.Method == "CONNECT" {
// If r.URL.Path is /tree and its handler is not registered,
// the /tree -> /tree/ redirect applies to CONNECT requests
// but the path canonicalization does not.
if u, ok := mux.redirectToPathSlash(r.URL.Host, r.URL.Path, r.URL); ok {
return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
}
return mux.handler(r.Host, r.URL.Path)
}
// 除去端口、清理路径
host := stripHostPort(r.Host)
path := cleanPath(r.URL.Path)
// 如果路径为 /tree 但没有相应的 handler，重定向至 /tree/.
if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok {
return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
}
if path != r.URL.Path {
_, pattern = mux.handler(host, path)
u := &url.URL{Path: path, RawQuery: r.URL.RawQuery}
return RedirectHandler(u.String(), StatusMovedPermanently), pattern
}
return mux.handler(host, r.URL.Path) // 匹配
}
// 该方法返回了给定路径请求的处理器。
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
mux.mu.RLock()
defer mux.mu.RUnlock()
// 特定于主机的模式优先于通用模式
// 本地测试下 host 为 localhost
if mux.hosts {
h, pattern = mux.match(host + path)
}
if h == nil {
h, pattern = mux.match(path)
}
if h == nil {
h, pattern = NotFoundHandler(), ""
}
return
}
match 真正包含了路径的匹配规则：
// 从保存 handler 的哈希表中找出一个符合该路径的 handler。
// 最具体的模式（最长）将被返回。
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
// 先查找完全符合的 handler。
v, ok := mux.m[path]
if ok {
return v.h, v.pattern
}
// 查找最长的匹配路径。mux.es 中包含了所有以 '/' 结尾的模式。
// 比如在注册时加入 '/hello/' 和 '/hi/'，
// 则 mux.es 中将保存为 ['/hello/', '/hi/']。
for _, e := range mux.es {
if strings.HasPrefix(path, e.pattern) {
return e.h, e.pattern
}
}
return nil, ""
}
至此，可以知道默认的路由方法为：
- 如果路径为
/tree但没有相应的handler，重定向至/tree/； - 如果能精确匹配，则利用此
handler处理； - 如果不能精确匹配，则匹配以
'/'结尾的最长路径。
验证 DefaultServeMux 路由规则
建立如下路径处理器：
func main() {
http.Handle("/greetings/", helloHandler("greetings"))
http.Handle("/greetings/hello", helloHandler("hello"))
http.Handle("/greetings/hi", helloHandler("hi"))
http.Handle("/farewell/bye", helloHandler("bye"))
http.Handle("/farewell/good_night", helloHandler("good night"))
http.Handle("/farewell/", helloHandler("farewell"))
http.ListenAndServe(":8080", nil)
}
type helloHandler string
func (h helloHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
writer.Write([]byte(h))
}
- 如果路径为
/tree但没有相应的handler，重定向至/tree/； - 当访问
/greetings/或/greetings/hello时，能返回相应的字符串"greetings""hello"； - 当访问
/greetings/bye时，由于不能精确匹配该路径，DefaultServeMux将调用/greetings/处理请求； - 当访问
/hello时，由于不能精确匹配该路径，DefaultServeMux将调用’/‘处理请求，由于没有注册'/'下的处理器，返回404 page not found。