网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

一日一学_Go语言HTTP Server(源码分析)

2020-06-10 04:17:16 admin 1188

Go语言中HTTP Server:

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

HTTP

HTTP服务简单实现

__

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6. )
  8. //③处理请求，返回结果
  9. func Hello(w http.ResponseWriter, r *http.Request) {
  10.     fmt.Fprintln(w, "hello world")
  11. }
  13. func main() {
  14.     //①路由注册
  15.     http.HandleFunc("/", Hello) 
  16.     //②服务监听
  17.     http.ListenAndServe(":8080", nil)
  18. }

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

源码分析

①路由注册
http中的HandleFunc方法,主要用来注册路由

__

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

DefaultServeMux是什么？
DefaultServeMux是ServeMux的一个实例。
ServeMux又是什么？

__

  1.  // DefaultServeMux is the default ServeMux used by Serve.
  2. var DefaultServeMux = &defaultServeMux
  4. var defaultServeMux ServeMux
  6. type ServeMux struct {
  7.     mu    sync.RWMutex
  8.     m     map[string]muxEntry
  9.     hosts bool 
  10. }
  12. type muxEntry struct {
  13.     explicit bool
  14.     h        Handler
  15.     pattern  string
  16. }

ServeMux主要通过map[string]muxEntry，来存储了具体的url模式和handler（此handler是实现Handler接口的类型）。通过实现Handler的ServeHTTP方法，来匹配路由（这一点下面源码会讲到）
很多地方都涉及到了Handler,那么Handler是什么？

__

  1. type Handler interface {
  2.     ServeHTTP(ResponseWriter, *Request)
  3. }

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

__

  1. func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
  2.     mux.Handle(pattern, HandlerFunc(handler))
  3. }
  5. type HandlerFunc func(ResponseWriter, *Request)
  7. func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
  8.     f(w, r)
  9. }

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

__

  1. func (mux *ServeMux) Handle(pattern string, handler Handler) {
  2.     mux.mu.Lock()
  3.     defer mux.mu.Unlock()
  5.     if pattern == "" {
  6.         panic("http: invalid pattern " + pattern)
  7.     }
  8.     if handler == nil {
  9.         panic("http: nil handler")
  10.     }
  11.     if mux.m[pattern].explicit {
  12.         panic("http: multiple registrations for " + pattern)
  13.     }
  15.     if mux.m == nil {
  16.         mux.m = make(map[string]muxEntry)
  17.     }
  18.     //把handler和pattern模式绑定到
  19.     //map[string]muxEntry的map上
  20.     mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}
  22.     if pattern[0] != '/' {
  23.         mux.hosts = true
  24.     }
  25.    //这里是绑定静态目录，不作为本片重点。
  26.     n := len(pattern)
  27.     if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit {
  29.         path := pattern
  30.         if pattern[0] != '/' {
  31.             path = pattern[strings.Index(pattern, "/"):]
  32.         }
  33.         url := &url.URL{Path: path}
  34.         mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern}
  35.     }
  36. }

上面的流程就完成了路由注册。
②服务监听

__

  1. type Server struct {
  2.     Addr         string        
  3.     Handler      Handler       
  4.     ReadTimeout  time.Duration 
  5.     WriteTimeout time.Duration 
  6.     TLSConfig    *tls.Config   
  8.     MaxHeaderBytes int
  10.     TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
  12.     ConnState func(net.Conn, ConnState)
  13.     ErrorLog *log.Logger
  14.     disableKeepAlives int32        nextProtoOnce     sync.Once 
  15.     nextProtoErr      error     
  16. }
  19. func ListenAndServe(addr string, handler Handler) error {
  20.     server := &Server{Addr: addr, Handler: handler}
  21.     return server.ListenAndServe()
  22. }
  24. //初始化监听地址Addr，同时调用Listen方法设置监听。
  25. //最后将监听的TCP对象传入Serve方法：
  26. func (srv *Server) ListenAndServe() error {
  27.         addr := srv.Addr
  28.         if addr == "" {
  29.             addr = ":http"
  30.         }
  31.         ln, err := net.Listen("tcp", addr)
  32.         if err != nil {
  33.             return err
  34.         }
  35.         return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
  36.     }

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

__

  1.  func (srv *Server) Serve(l net.Listener) error {
  2.     defer l.Close()
  3.     if fn := testHookServerServe; fn != nil {
  4.         fn(srv, l)
  5.     }
  6.     var tempDelay time.Duration // how long to sleep on accept failure
  8.     if err := srv.setupHTTP2_Serve(); err != nil {
  9.         return err
  10.     }
  12.     srv.trackListener(l, true)
  13.     defer srv.trackListener(l, false)
  15.     baseCtx := context.Background() // base is always background, per Issue 16220
  16.     ctx := context.WithValue(baseCtx, ServerContextKey, srv)
  17.     ctx = context.WithValue(ctx, LocalAddrContextKey, l.Addr())
  18.     //开启循环进行监听
  19.     for {
  20.        //通过Listener的Accept方法用来获取连接数据
  21.         rw, e := l.Accept()
  22.         if e != nil {
  23.             select {
  24.             case <-srv.getDoneChan():
  25.                 return ErrServerClosed
  26.             default:
  27.             }
  28.             if ne, ok := e.(net.Error); ok && ne.Temporary() {
  29.                 if tempDelay == 0 {
  30.                     tempDelay = 5 * time.Millisecond
  31.                 } else {
  32.                     tempDelay *= 2
  33.                 }
  34.                 if max := 1 * time.Second; tempDelay > max {
  35.                     tempDelay = max
  36.                 }
  37.                 srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
  38.                 time.Sleep(tempDelay)
  39.                 continue
  40.             }
  41.             return e
  42.         }
  43.         tempDelay = 0
  44.         //通过获得的连接数据，创建newConn连接对象
  45.         c := srv.newConn(rw)
  46.                 c.setState(c.rwc, StateNew) // before Serve can return
  47.        //开启goroutine发送连接请求
  48.         go c.serve(ctx)
  49.     }
  50. }

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

__

  1. func (c *conn) serve(ctx context.Context) {
  2.     c.remoteAddr = c.rwc.RemoteAddr().String()
  3.         //连接关闭相关的处理
  4.     defer func() {
  5.         if err := recover(); err != nil && err != ErrAbortHandler {
  6.             const size = 64 << 10
  7.             buf := make([]byte, size)
  8.             buf = buf[:runtime.Stack(buf, false)]
  9.             c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)
  10.         }
  11.         if !c.hijacked() {
  12.             c.close()
  13.             c.setState(c.rwc, StateClosed)
  14.         }
  15.     }()
  17.     .....
  19.     ctx, cancelCtx := context.WithCancel(ctx)
  20.     c.cancelCtx = cancelCtx
  21.     defer cancelCtx()
  23.     c.r = &connReader{conn: c}
  24.     c.bufr = newBufioReader(c.r)
  25.     c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)
  27.     for {
  28.         //读取客户端的请求
  29.         w, err := c.readRequest(ctx)
  30.         if c.r.remain != c.server.initialReadLimitSize() {
  31.             // If we read any bytes off the wire, we're active.
  32.             c.setState(c.rwc, StateActive)
  33.         }
  35.                 .................
  36.         //处理网络数据的状态
  37.         // Expect 100 Continue support
  38.         req := w.req
  39.         if req.expectsContinue() {
  40.             if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
  41.                 // Wrap the Body reader with one that replies on the connection
  42.                 req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
  43.             }
  44.         } else if req.Header.get("Expect") != "" {
  45.             w.sendExpectationFailed()
  46.             return
  47.         }
  49.         c.curReq.Store(w)
  51.         if requestBodyRemains(req.Body) {
  52.             registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)
  53.         } else {
  54.             if w.conn.bufr.Buffered() > 0 {
  55.                 w.conn.r.closeNotifyFromPipelinedRequest()
  56.             }
  57.             w.conn.r.startBackgroundRead()
  58.         }
  60.         //调用serverHandler{c.server}.ServeHTTP(w, w.req)
  61.         //方法处理请求
  62.         serverHandler{c.server}.ServeHTTP(w, w.req)
  63.         w.cancelCtx()
  64.         if c.hijacked() {
  65.             return
  66.         }
  67.         w.finishRequest()
  68.         if !w.shouldReuseConnection() {
  69.             if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
  70.                 c.closeWriteAndWait()
  71.             }
  72.             return
  73.         }
  74.         c.setState(c.rwc, StateIdle)
  75.         c.curReq.Store((*response)(nil))
  77.         if !w.conn.server.doKeepAlives() {
  78.             return
  79.         }
  81.         if d := c.server.idleTimeout(); d != 0 {
  82.             c.rwc.SetReadDeadline(time.Now().Add(d))
  83.             if _, err := c.bufr.Peek(4); err != nil {
  84.                 return
  85.             }
  86.         }
  87.         c.rwc.SetReadDeadline(time.Time{})
  88.     }
  89. }

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

__

  1. type serverHandler struct {
  2.     srv *Server
  3. }
  5. func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
  6.     handler := sh.srv.Handler
  7.     if handler == nil {
  8.         handler = DefaultServeMux
  9.     }
  10.     if req.RequestURI == "*" && req.Method == "OPTIONS" {
  11.         handler = globalOptionsHandler{}
  12.     }
  13.     handler.ServeHTTP(rw, req)
  14. }

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

__

  1. func (mux *ServeMux) ServeHTTP (w ResponseWriter, r *Request) {
  2.     if r.RequestURI == "*" {
  3.         if r.ProtoAtLeast(1, 1) {
  4.             w.Header().Set("Connection", "close")
  5.         }
  6.         w.WriteHeader(StatusBadRequest)
  7.         return
  8.     }
  9.     //匹配注册到路由上的handler函数
  10.     h, _ := mux.Handler(r)
  11.     //调用handler函数的ServeHTTP方法
  12.     //即Hello函数，然后把数据写到http.ResponseWriter
  13.     //对象中返回给客户端。
  14.     h.ServeHTTP(w, r)
  15. }
  17. func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
  18.     if r.Method != "CONNECT" {
  19.         if p := cleanPath(r.URL.Path); p != r.URL.Path {
  20.             _, pattern = mux.handler(r.Host, p)
  21.             url := *r.URL
  22.             url.Path = p
  23.             return RedirectHandler(url.String(), StatusMovedPermanently), pattern
  24.         }
  25.     }
  26.     return mux.handler(r.Host, r.URL.Path)
  27. }
  29. func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
  30.     mux.mu.RLock()
  31.     defer mux.mu.RUnlock()
  33.     // Host-specific pattern takes precedence over generic ones
  34.     if mux.hosts {
  35.         //如 127.0.0.1/hello
  36.         h, pattern = mux.match(host + path)
  37.     }
  38.     if h == nil {
  39.         // 如  /hello
  40.         h, pattern = mux.match(path)
  41.     }
  42.     if h == nil {
  43.         h, pattern = NotFoundHandler(), ""
  44.     }
  45.     return
  46. }
  48. func (mux *ServeMux) match(path string) (h Handler, pattern string) {
  49.     var n = 0
  50.     for k, v := range mux.m {
  51.         if !pathMatch(k, path) {
  52.             continue
  53.         }
  54.       //通过迭代m寻找出注册路由的patten模式
  55.       //与实际url匹配的handler函数并返回。
  56.         if h == nil || len(k) > n {
  57.             n = len(k)
  58.             h = v.h
  59.             pattern = v.pattern
  60.         }
  61.     }
  62.     return
  63. }
  64. func pathMatch(pattern, path string) bool {
  65.     if len(pattern) == 0 {
  66.         // should not happen
  67.         return false
  68.     }
  69.     n := len(pattern)
  70.         //如果注册模式与请求uri一样返回true，否则false
  71.     if pattern[n-1] != '/' {
  72.         return pattern == path
  73.     }
  74.         //静态文件匹配
  75.     return len(path) >= n && path[0:n] == pattern
  76. }

将数据写给客户端

__

  1. //主要代码，通过层层封装才走到这一步
  4. func (w checkConnErrorWriter) Write(p []byte) (n int, err error) {
  5.     n, err = w.c.rwc.Write(p)
  6.     if err != nil && w.c.werr == nil {
  7.         w.c.werr = err
  8.         w.c.cancelCtx()
  9.     }
  10.     return
  11. }

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

总结
Go语言通过一个ServeMux实现了的路由多路复用器来管理路由。同时提供一个Handler接口提供ServeHTTP方法，实现handler接口的函数，可以处理实际request并返回response。
ServeMux和handler函数的连接桥梁就是Handler接口。ServeMux的ServeHTTP方法实现了寻找注册路由的handler的函数，并调用该handler的ServeHTTP方法。
所以说Handler接口是一个重要枢纽。

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

HTTP Server流程图

转载文章，原文链接： 一日一学_Go语言HTTP Server(源码分析)

关键字词源码一学

分享到：

上一篇：Golang通过HTTP Response获取Zip文件

下一篇： go语言坑之for range

如需留言，请 登录，没有账号？请 注册

0 条评论 0 人参与

顶部 底部