参考文档
基于 net/http web 服务端 示例
package main
import(
"fmt"
"log"
"net/http"
)
func main() {
http.HandleFunc("/", func1)
http.HandleFunc("/hello", func2)
log.Fatal(http.ListenAndServe(":6665", nil))
}
func func1(w http.ResponseWriter, req *http.Request){
fmt.Fprintf(w, "URL.Path = %q\n", req.URL.Path)
}
func func2(w http.ResponseWriter, req *http.Request) {
for k, v := range req.Header {
fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
}
}
这段代码调用 http.HandleFunc 进行了路由注册，再调用ListenAndServe进行监听，运行结果如下
[root@localhost ~]# curl http://127.0.0.1:6665/
URL.Path = "/"
[root@localhost ~]#
关键过程分析
路由注册
几个关键的数据结构，和变量
//保存服务端路由映射
type ServeMux struct {
mu sync.RWMutex
m map[string]muxEntry
hosts bool // whether any patterns contain hostnames
}
//记录一条路由映射
type muxEntry struct {
h Handler
pattern string
}
// http 内置默认路由.
var DefaultServeMux = &defaultServeMux
var defaultServeMux ServeMux
//函数类型，我们示例代码中， 传入的函数变量，就是该数据类型
type HandlerFunc func(ResponseWriter, *Request)
//注意HandlerFunc实现了ServeHTTP方法
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
//接口类型，实现ServeHTTP函数， 这是实际处理客户端请求的函数，非常重要
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
api调用跟踪
http.HandleFunc("/", func1)
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
mux.Handle(pattern, HandlerFunc(handler)) //将变量，转化成 type HandlerFunc
}
func (mux *ServeMux) Handle(pattern string, handler Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()
//此处省略很多代码
mux.m[pattern] = muxEntry{h: handler, pattern: pattern} //建立url 与 处理函数的映射
//此处省略很多代码
}
自此，路由注册完成， 路由信息，应该会全部注册到 DefaultServeMux 变量。
下面我们调试一下，确认我们的分析。
[root@localhost httpserver]# dlv debug main.go --check-go-version=false
Type 'help' for list of commands.
(dlv) b main.go:12
Breakpoint 1 set at 0x6e6e59 for main.main() ./main.go:12
(dlv) c
> main.main() ./main.go:12 (hits goroutine(1):1 total:1) (PC: 0x6e6e59)
7: )
8:
9: func main() {
10: http.HandleFunc("/", func1)
11: http.HandleFunc("/hello", func2)
=> 12: log.Fatal(http.ListenAndServe(":6665", nil))
13: }
14:
15: func func1(w http.ResponseWriter, req *http.Request){
16: fmt.Fprintf(w, "URL.Path = %q\n", req.URL.Path)
17: }
(dlv) p http.DefaultServeMux
*net/http.ServeMux {
mu: sync.RWMutex {
w: (*sync.Mutex)(0x8eba60),
writerSem: 0,
readerSem: 0,
readerCount: 0,
readerWait: 0,},
m: map[string]net/http.muxEntry [
"/": (*"net/http.muxEntry")(0xc420012a48),
"/hello": (*"net/http.muxEntry")(0xc420012a68),
],
hosts: false,}
(dlv) q
[root@localhost httpserver]#
疑问点
传入的函数变量，为什么不是直接和url映射， 而是经过 2次 转换，第一次转换为HandlerFunc, 第二次转换为 handler，即 转换为一个接口类型。
因为我们的例子中，是传入一个函数变量，单单传一个函数过去， 能做的事情太少了。实际应用会复杂一些。如果有看过相关web框架源码就知道，一般不会使用默认的ServeMux。
如果传一个结构体过去，可以实现更复杂的功能，当结构体作为一个合法参数。这种方式适用于逻辑较为复杂的场景，如果对数据库的操作需要很多信息，地址、用户名、密码，还有很多中间状态需要保持，比如超时、重连、加锁等等。这种情况下，更适合封装为一个结构体作为参数。
上述也称为接口函数，既能够将普通的函数类型（需类型转换）作为参数，也可以将结构体作为参数，使用更为灵活，可读性也更好，这就是接口型函数的价值。
也可以参考下这篇博文 https://geektutu.com/post/7days-golang-q1.html
服务端响应分析
使用很广泛的apache使用的是多进程模型， apache会维护一个进程池， 新的请求到来，就取一个进程去处理，或者根据策略创建一个新的子进程。
golang 使用的当然就是 go 协程了， 分析一下它是怎么响应请求到。
几个关键数据结构
// A Server defines parameters for running an HTTP server.
// The zero value for Server is a valid configuration.
type Server struct {
Addr string // TCP address to listen on, ":http" if empty
Handler Handler // handler to invoke, http.DefaultServeMux if nil
TLSConfig *tls.Config
ReadTimeout time.Duration
ReadHeaderTimeout time.Duration
WriteTimeout time.Duration
IdleTimeout time.Duration
MaxHeaderBytes int
TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
ConnState func(net.Conn, ConnState)
ErrorLog *log.Logger
disableKeepAlives int32 // accessed atomically.
inShutdown int32 // accessed atomically (non-zero means we're in Shutdown)
nextProtoOnce sync.Once // guards setupHTTP2_* init
nextProtoErr error // result of http2.ConfigureServer if used
mu sync.Mutex
listeners map[net.Listener]struct{}
activeConn map[*conn]struct{}
doneChan chan struct{}
onShutdown []func()
}
// A conn represents the server side of an HTTP connection.
type conn struct {
server *Server
cancelCtx context.CancelFunc
rwc net.Conn
remoteAddr string
tlsState *tls.ConnectionState
werr error
r *connReader
bufr *bufio.Reader
bufw *bufio.Writer
lastMethod string
curReq atomic.Value
curState atomic.Value
mu sync.Mutex
hijackedv bool
}
//就是封装的一个server 指针
type serverHandler struct {
srv *Server
}
先从示例代码的 http.ListenAndServe(":6665", nil) 开始分析“
记住我们传入的Handler 是nil
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)})
}
//监听到请求， 通过go 协程处理： go c.serve(ctx)
func (srv *Server) Serve(l net.Listener) error {
//此处省略很多代码
for {
rw, e := l.Accept()
//此处省略很多代码
c := srv.newConn(rw)
c.setState(c.rwc, StateNew) // before Serve can return
go c.serve(ctx)
}
}
这就是章节开头说的， apache是过进程模型， 而net/http 就是靠go 协程去并发处理请求。
这里又有一个疑问，我们用apache时， 内部代码异常了，即使没有catch， web服务也不会退出，因为多进程模型，子进程异常退出，并不会导致父进程退出，
那用net/http时， 假如在我们的示例代码中出现panic， web服务也是不会退出的（这里就不贴测试代码了） 那它时怎么是实现的， 我猜肯定时用到了 defer + recover
我们继续分析web服务处理请求的过程。
处理过程最终
go c.serve(ctx)
调用newConn返回的是什么呢
func (srv *Server) newConn(rwc net.Conn) *conn {
c := &conn{
server: srv,
rwc: rwc,
}
if debugServerConnections {
c.rwc = newLoggingConn("server", c.rwc)
}
return c
}
c.server的具体实现中就使用了 defer + revocer， 如下：
// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
..........................................
defer func() {
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)
}
}()
//此处省略了很多代码
//留意注意这里的for循环, 长连接时， 这个go协程就不会退出
//当时最终调用的处理函数是： serverHandler{c.server}.ServeHTTP(w, w.req)
for {
w, err := c.readRequest(ctx)
//此处省略了很多代码
// HTTP cannot have multiple simultaneous active requests.[*]
// Until the server replies to this request, it can't read another,
// so we might as well run the handler in this goroutine.
// [*] Not strictly true: HTTP pipelining. We could let them all process
// in parallel even if their responses need to be serialized.
// But we're not going to implement HTTP pipelining because it
// was never deployed in the wild and the answer is HTTP/2.
serverHandler{c.server}.ServeHTTP(w, w.req)
//此处省略了很多代码
if !w.conn.server.doKeepAlives() {
// We're in shutdown mode. We might've replied
// to the user without "Connection: close" and
// they might think they can send another
// request, but such is life with HTTP/1.1.
return
}
//此处省略了很多代码
}
}
继续跟踪 serverHandler{c.server}.ServeHTTP(w, w.req)
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
handler := sh.srv.Handler
if handler == nil { //示例代码。我们传入的就是nil
handler = DefaultServeMux
}
if req.RequestURI == "*" && req.Method == "OPTIONS" {
handler = globalOptionsHandler{}
}
handler.ServeHTTP(rw, req)
}
DefaultServeMux的类型是 ServeMux， 继续跟踪
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
if r.RequestURI == "*" {
if r.ProtoAtLeast(1, 1) {
w.Header().Set("Connection", "close")
}
w.WriteHeader(StatusBadRequest)
return
}
h, _ := mux.Handler(r) // 找到最终 Handler
h.ServeHTTP(w, r) // 调用ServeHTTP方法
}
怎么找到Handler的呢
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
//此处省略了很多代码
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()
//此处省略了很多代码
h, pattern = mux.match(path)
//此处省略了很多代码
}
// Find a handler on a handler map given a path string.
// Most-specific (longest) pattern wins.
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
// Check for exact match first.
v, ok := mux.m[path]
if ok {
return v.h, v.pattern
}
//此处省略了很多代码
}
还记得最开始的那个数据结构吗
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
我们注册是，传入的函数变量经过2次转换，转换成Handler 类型，其ServeHTTP方法就是其函数变量 自身。
其实， 一些web框架， 就是传入的 handler 是我们自己定义的而，不是传nil(最终会使用DefaultServeMux)
http.ListenAndServe(":6665", nil)
|
|
——————
func ListenAndServe(addr string, handler Handler) error {
server := &Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}
|
|
——————
handler := sh.srv.Handler
if handler == nil {
handler = DefaultServeMux
}
至此，路由注册， 根据url找到对应api, 并执行， 这一些列过程， 已经分析完成。
整个分析过程，我们使用的是net/http的默认路由，api追踪过程，也是做了很多理想情况的假设
我们分析了 net/http 默认路由中注册过程， 服务端如何实现并发处理请求，以及如何进行异常恢复，以及长连接保持
后续还会对httpclient， 长连接， context的使用做分析