Go语言HTTP Server源码分析

Go语言中HTTP Server:

HTTP server，顾名思义，支持http协议的服务器，HTTP是一个简单的请求-响应协议，通常运行在TCP之上。通过客户端发送请求给服务器得到对应的响应。

HTTP服务简单实现

 
 


  
  
package main  

  
  
import ( 

  
  
    "fmt" 

  
  
    "net/http" 

  
  
)  

  
  
//③处理请求，返回结果 

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

  
  
    fmt.Fprintln(w, "hello world") 

  
  
}  

  
  
func main() { 

  
  
    //①路由注册 

  
  
    http.HandleFunc("/", Hello)  

  
  
    //②服务监听 

  
  
    http.ListenAndServe(":8080", nil) 

  
  
} 
 
 

你以为这样就结束了吗，不才刚刚开始。

源码分析

①路由注册

 
 


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

  
  
    DefaultServeMux.HandleFunc(pattern, handler) 

  
  
} 
 
 

DefaultServeMux是什么?

DefaultServeMux是ServeMux的一个实例。

ServeMux又是什么?

 
 


  
  
// DefaultServeMux is the default ServeMux used by Serve. 

  
  
var DefaultServeMux = &defaultServeMux  

  
  
var defaultServeMux ServeMux  

  
  
type ServeMux struct { 

  
  
    mu    sync.RWMutex 

  
  
    m     map[string]muxEntry 

  
  
    hosts bool  

  
  
}  

  
  
type muxEntry struct { 

  
  
    explicit bool 

  
  
    h        Handler 

  
  
    pattern  string 

  
  
} 
 
 

ServeMux主要通过map[string]muxEntry，来存储了具体的url模式和handler(此handler是实现Handler接口的类型)。通过实现Handler的ServeHTTP方法，来匹配路由(这一点下面源码会讲到)

很多地方都涉及到了Handler,那么Handler是什么?

 
 


  
  
type Handler interface { 

  
  
    ServeHTTP(ResponseWriter, *Request) 

  
  
} 
 
 

此接口可以算是HTTP Server一个枢纽

 
 


  
  
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) { 

  
  
    mux.Handle(pattern, HandlerFunc(handler)) 

  
  
}  

  
  
type HandlerFunc func(ResponseWriter, *Request)  

  
  
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { 

  
  
    f(w, r) 

  
  
} 
 
 

从代码中可以看出HandlerFunc是一个函数类型，并实现了Handler接口。当通过调用HandleFunc()，把Hello强转为HandlerFunc类型时，就意味着 Hello函数也实现ServeHTTP方法。

ServeMux的Handle方法:

 
 


  
  
func (mux *ServeMux) Handle(pattern string, handler Handler) { 

  
  
    mux.mu.Lock() 

  
  
    defer mux.mu.Unlock()  

  
  
    if pattern == "" { 

  
  
        panic("http: invalid pattern " + pattern) 

  
  
    } 

  
  
    if handler == nil { 

  
  
        panic("http: nil handler") 

  
  
    } 

  
  
    if mux.m[pattern].explicit { 

  
  
        panic("http: multiple registrations for " + pattern) 

  
  
    }  

  
  
    if mux.m == nil { 

  
  
        mux.m = make(map[string]muxEntry) 

  
  
    } 

  
  
    //把handler和pattern模式绑定到 

  
  
    //map[string]muxEntry的map上 

  
  
    mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern} 

  
  
 

  
  
    if pattern[0] != '/' { 

  
  
        mux.hosts = true 

  
  
    } 

  
  
   //这里是绑定静态目录，不作为本片重点。 

  
  
    n := len(pattern) 

  
  
    if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit { 

  
  
 

  
  
        path := pattern 

  
  
        if pattern[0] != '/' { 

  
  
            path = pattern[strings.Index(pattern, "/"):] 

  
  
        } 

  
  
        url := &url.URL{Path: path} 

  
  
        mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern} 

  
  
    } 

  
  
} 
 
 

上面的流程就完成了路由注册。

②服务监听

 
 


  
  
type Server struct { 

  
  
    Addr         string         

  
  
    Handler      Handler        

  
  
    ReadTimeout  time.Duration  

  
  
    WriteTimeout time.Duration  

  
  
    TLSConfig    *tls.Config    



  
  
    MaxHeaderBytes int  

  
  
    TLSNextProto map[string]func(*Server, *tls.Conn, Handler)  

  
  
    ConnState func(net.Conn, ConnState) 

  
  
    ErrorLog *log.Logger 

  
  
    disableKeepAlives int32        nextProtoOnce     sync.Once  

  
  
    nextProtoErr      error      

  
  
}  

  
  
func ListenAndServe(addr string, handler Handler) error { 

  
  
    server := &Server{Addr: addr, Handler: handler} 

  
  
    return server.ListenAndServe() 

  
  
}  

  
  
//初始化监听地址Addr，同时调用Listen方法设置监听。 

  
  
//最后将监听的TCP对象传入Serve方法： 

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

  
  
    } 
 
 

Serve(l net.Listener)为每个请求开启goroutine的设计，保证了go的高并发。

 
 


  
  
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 { 

  
  
       //通过Listener的Accept方法用来获取连接数据 

  
  
        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 

  
  
        //通过获得的连接数据，创建newConn连接对象 

  
  
        c := srv.newConn(rw) 

  
  
                c.setState(c.rwc, StateNew) // before Serve can return 

  
  
       //开启goroutine发送连接请求 

  
  
        go c.serve(ctx) 

  
  
    } 

  
  
} 
 
 

serve()为核心,读取对应的连接数据进行分配

 
 


  
  
func (c *conn) serve(ctx context.Context) { 

  
  
    c.remoteAddr = c.rwc.RemoteAddr().String() 

  
  
        //连接关闭相关的处理 

  
  
    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) 

  
  
        } 

  
  
    }()  

  
  
    .....  

  
  
    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() { 

  
  
            // If we read any bytes off the wire, we're active. 

  
  
            c.setState(c.rwc, StateActive) 

  
  
        } 

  
  
                ................. 

  
  
        //处理网络数据的状态 

  
  
        // Expect 100 Continue support 

  
  
        req := w.req 

  
  
        if req.expectsContinue() { 

  
  
            if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 { 

  
  
                // Wrap the Body reader with one that replies on the connection 

  
  
                req.Body = &expectContinueReader{readCloser: req.Body, resp: w} 

  
  
            } 

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

  
  
            if w.conn.bufr.Buffered() > 0 { 

  
  
                w.conn.r.closeNotifyFromPipelinedRequest() 

  
  
            } 

  
  
            w.conn.r.startBackgroundRead() 

  
  
        }  

  
  
        //调用serverHandler{c.server}.ServeHTTP(w, w.req) 

  
  
        //方法处理请求 

  
  
        serverHandler{c.server}.ServeHTTP(w, w.req) 

  
  
        w.cancelCtx() 

  
  
        if c.hijacked() { 

  
  
            return 

  
  
        } 

  
  
        w.finishRequest() 

  
  
        if !w.shouldReuseConnection() { 

  
  
            if w.requestBodyLimitHit || w.closedRequestBodyEarly() { 

  
  
                c.closeWriteAndWait() 

  
  
            } 

  
  
            return 

  
  
        } 

  
  
        c.setState(c.rwc, StateIdle) 

  
  
        c.curReq.Store((*response)(nil)) 

  
  
 

  
  
        if !w.conn.server.doKeepAlives() { 

  
  
            return 

  
  
        } 

  
  
 

  
  
        if d := c.server.idleTimeout(); d != 0 { 

  
  
            c.rwc.SetReadDeadline(time.Now().Add(d)) 

  
  
            if _, err := c.bufr.Peek(4); err != nil { 

  
  
                return 

  
  
            } 

  
  
        } 

  
  
        c.rwc.SetReadDeadline(time.Time{}) 

  
  
    } 

  
  
} 
 
 

③处理请求，返回结果

serverHandler 主要初始化路由多路复用器。如果server对象没有指定Handler，则使用默认的DefaultServeMux作为路由多路复用器。并调用初始化Handler的ServeHTTP方法。

 
 


  
  
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) 

  
  
} 
 
 

这里就是之前提到的匹配路由的具体代码

 
 


  
  
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 

  
  
    } 

  
  
    //匹配注册到路由上的handler函数 

  
  
    h, _ := mux.Handler(r) 

  
  
    //调用handler函数的ServeHTTP方法 

  
  
    //即Hello函数，然后把数据写到http.ResponseWriter 

  
  
    //对象中返回给客户端。 

  
  
    h.ServeHTTP(w, r) 

  
  
} 



  
  
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) { 

  
  
    if r.Method != "CONNECT" { 

  
  
        if p := cleanPath(r.URL.Path); p != r.URL.Path { 

  
  
            _, pattern = mux.handler(r.Host, p) 

  
  
            url := *r.URL 

  
  
            url.Path = p 

  
  
            return RedirectHandler(url.String(), StatusMovedPermanently), pattern 

  
  
        } 

  
  
    } 

  
  
    return mux.handler(r.Host, r.URL.Path) 

  
  
}  

  
  
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) { 

  
  
    mux.mu.RLock() 

  
  
    defer mux.mu.RUnlock() 

  
  
 

  
  
    // Host-specific pattern takes precedence over generic ones 

  
  
    if mux.hosts { 

  
  
        //如 127.0.0.1/hello 

  
  
        h, pattern = mux.match(host + path) 

  
  
    } 

  
  
    if h == nil { 

  
  
        // 如  /hello 

  
  
        h, pattern = mux.match(path) 

  
  
    } 

  
  
    if h == nil { 

  
  
        h, pattern = NotFoundHandler(), "" 

  
  
    } 

  
  
    return 

  
  
}  

  
  
func (mux *ServeMux) match(path string) (h Handler, pattern string) { 

  
  
    var n = 0 

  
  
    for k, v := range mux.m { 

  
  
        if !pathMatch(k, path) { 

  
  
            continue 

  
  
        } 

  
  
      //通过迭代m寻找出注册路由的patten模式 

  
  
      //与实际url匹配的handler函数并返回。 

  
  
        if h == nil || len(k) > n { 

  
  
            n = len(k) 

  
  
            h = v.h 

  
  
            pattern = v.pattern 

  
  
        } 

  
  
    } 

  
  
    return 

  
  
} 

  
  
func pathMatch(pattern, path string) bool { 

  
  
    if len(pattern) == 0 { 

  
  
        // should not happen 

  
  
        return false 

  
  
    } 

  
  
    n := len(pattern) 

  
  
        //如果注册模式与请求uri一样返回true，否则false 

  
  
    if pattern[n-1] != '/' { 

  
  
        return pattern == path 

  
  
    } 

  
  
        //静态文件匹配 

  
  
    return len(path) >= n && path[0:n] == pattern 

  
  
} 
 
 

将数据写给客户端

 
 


  
  
//主要代码，通过层层封装才走到这一步 

  
  
 

  
  
func (w checkConnErrorWriter) Write(p []byte) (n int, err error) { 

  
  
    n, err = w.c.rwc.Write(p) 

  
  
    if err != nil && w.c.werr == nil { 

  
  
        w.c.werr = err 

  
  
        w.c.cancelCtx() 

  
  
    } 

  
  
    return 

  
  
} 
 
 

serverHandler{c.server}.ServeHTTP(w, w.req)当请求结束后，就开始执行连接断开的相关逻辑。

总结

Go语言通过一个ServeMux实现了的路由多路复用器来管理路由。同时提供一个Handler接口提供ServeHTTP方法，实现handler接口的函数，可以处理实际request并返回response。

ServeMux和handler函数的连接桥梁就是Handler接口。ServeMux的ServeHTTP方法实现了寻找注册路由的handler的函数，并调用该handler的ServeHTTP方法。

所以说Handler接口是一个重要枢纽。

简单梳理下整个请求响应过程，如下图

作者：佚名

来源：51CTO