参考
HTTP
网络发展,很多网络应用都是构建再 HTTP 服务基础之上。HTTP 协议从诞生到现在,发展从1.0,1.1到2.0也不断再进步。除去细节,理解 HTTP 构建的网络应用只要关注两个端---客户端(clinet)和服务端(server),两个端的交互来自 clinet 的 request,以及 server 端的 response。所谓的 http 服务器,主要在于如何接受 clinet 的 request,并向 client 返回 response。
接收request的过程中,最重要的莫过于路由(router
),即实现一个Multiplexer
(多路复用器)。Go中既可以使用内置的mutilplexer
--- DefautServeMux,也可以自定义。Multiplexer
路由的目的就是为了找到处理器函数(handler),后者将对request进行处理,同时构建response。
Clinet -> Requests -> [Multiplexer(router) -> handler -> Response -> Clinet
首先看一个最简单的 http 服务器的实现:
// mini web server
package main
import (
"fmt"
"log"
"net/http"
)
func IndexHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "<h1>hello world</h1>")
}
func main() {
http.HandleFunc("/", IndexHandler)
log.Fatal(http.ListenAndServe(":9090", nil))
}
这段程序的作用是在本机的 9090 端口开启一个 web 服务,当访问 http://localhost:9090/ 时,网页会显示 hello world。
我们根据这段程序进行分析,从 main() 函数入手。
HandleFunc 与 Handler
下面是 Handler 接口的定义。可以看出它要求实现 ServeHTTP 方法。
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
handler 用来响应 HTTP 请求,ServeHTTP 方法会将回复的 header 以及 data 都写到 ResponseWriter
中然后返回。如同我们上面的 IndexHandler 做的一样。
但是,一旦完成了 ServeHTTP 调用,我们就不能再读取 Request.Body
,也不能再使用 ResponseWrite
。
由于 HTTP 客户端,HTTP 协议版本,以及客户端与服务器之间的过程,我们可能在写入 ResponseWrite
之后就立刻无法读取 Request.Body
了。因此我们应该首先读取 Request.Body
,再回复。
注意,Request
是只读的,不能修改。
// http.HandleFunc
func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
HandleFunc 将 handle function 注册给一个 pattern,就像我们在上面的程序中将 IndexHandler
注册给了根目录 "/"
。以后访问根目录就会使用对应 handler 进行处理。具体的如何匹配 pattern 就需要了解 ServeMux 了。
ServeMux
ServeMux 是一个 HTTP 请求的多路复用器。它会将请求的 URL 与已注册的所有 pattern 进行匹配,然后调用最相似的一个。
假设我们要访问以 "/images/thumbnails/" 开始的路径,而现在已经注册了 "/images/" 以及 "/images/thumbnails/" ,那么显然 "/images/thumbnails/" 对应的 handle function 会进行处理。
因此,根目录 "/"
不仅仅能匹配以 "/"
为路径的 URL,当没有其他能匹配的 pattern 时,也会匹配到根目录。
ServeMux 的实现很简单,主要是基于一个字典进行查询。
type ServeMux struct {
mu sync.RWMutex
m map[string]muxEntry
hosts bool
}
type muxEntry struct {
explicit bool
h Handler
pattern string
}
Server
现在就只有一行代码还需要分析了。
log.Fatal(http.ListenAndServe(":9090", nil))
第一个参数是监听的端口。第二个参数是支持一个自定义的 multiplexer,如果为 nil 则用默认的。
在源码中可以找到相关的函数:
- 建立新的 Server 实例,并设置了地址以及 multiplexer,开始监听和服务。
func ListenAndServe(addr string, handler Handler) error { server := &Server{Addr: addr, Handler: handler} return server.ListenAndServe() }
- 监听端口
核心代码是func (srv *Server) ListenAndServe() error { addr := srv.Addr if addr == "" { addr = ":http" } ln, err := net.Listen("tcp", addr) if err != nil { return err } return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)}) }
ln, err := net.Listen("tcp", addr)
。 -
处理新的连接
func (srv *Server) Serve(l net.Listener) error { defer l.Close() if fn := testHookServerServe; fn != nil { fn(srv, l) } var tempDelay time.Duration // how long to sleep on accept failure if err := srv.setupHTTP2_Serve(); err != nil { return err } srv.trackListener(l, true) defer srv.trackListener(l, false) baseCtx := context.Background() // base is always background, per Issue 16220 ctx := context.WithValue(baseCtx, ServerContextKey, srv) ctx = context.WithValue(ctx, LocalAddrContextKey, l.Addr()) for { rw, e := l.Accept() if e != nil { select { case <-srv.getDoneChan(): return ErrServerClosed default: } if ne, ok := e.(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", e, tempDelay) time.Sleep(tempDelay) continue } return e } tempDelay = 0 c := srv.newConn(rw) c.setState(c.rwc, StateNew) // before Serve can return go c.serve(ctx) } }
这里主要开启了一个 for 循环,对于每个新的连接都建立一个 goroutine 处理,体现了高并发思想。
- 每个连接的处理逻辑
这个函数就比较长了,暂时不贴代码了。
做的事主要是:- 解析客户端请求
- 选择 multiplexer,如果是 nil 则使用 DefaultServeMux
- 使用 multiplexer 找到请求 uri 所对应的 handler
- 写入 ResponseWriter 并回复给客户端
至此,就理解了 http 服务的工作原理了。
有疑问加站长微信联系(非本文作者)