开发者社区> 行者武松> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Go语言HTTP Server源码分析

简介:
+关注继续查看

Go语言中HTTP Server:

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

HTTP服务简单实现


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

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

源码分析

①路由注册


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

DefaultServeMux是什么?

DefaultServeMux是ServeMux的一个实例。

ServeMux又是什么?


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

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

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


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

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


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

从代码中可以看出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()  
  4.     if pattern == "" { 
  5.         panic("http: invalid pattern " + pattern) 
  6.     } 
  7.     if handler == nil { 
  8.         panic("http: nil handler"
  9.     } 
  10.     if mux.m[pattern].explicit { 
  11.         panic("http: multiple registrations for " + pattern) 
  12.     }  
  13.     if mux.m == nil { 
  14.         mux.m = make(map[string]muxEntry) 
  15.     } 
  16.     //把handler和pattern模式绑定到 
  17.     //map[string]muxEntry的map上 
  18.     mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern} 
  19.  
  20.     if pattern[0] != '/' { 
  21.         mux.hosts = true 
  22.     } 
  23.    //这里是绑定静态目录,不作为本片重点。 
  24.     n := len(pattern) 
  25.     if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit { 
  26.  
  27.         path := pattern 
  28.         if pattern[0] != '/' { 
  29.             path = pattern[strings.Index(pattern, "/"):] 
  30.         } 
  31.         url := &url.URL{Path: path} 
  32.         mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern} 
  33.     } 

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

②服务监听


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

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

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.     }()  
  16.     .....  
  17.     ctx, cancelCtx := context.WithCancel(ctx) 
  18.     c.cancelCtx = cancelCtx 
  19.     defer cancelCtx() 
  20.  
  21.     c.r = &connReader{conn: c} 
  22.     c.bufr = newBufioReader(c.r) 
  23.     c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)  
  24.     for { 
  25.         //读取客户端的请求 
  26.         w, err := c.readRequest(ctx) 
  27.         if c.r.remain != c.server.initialReadLimitSize() { 
  28.             // If we read any bytes off the wire, we're active. 
  29.             c.setState(c.rwc, StateActive) 
  30.         }
  31.                 ................. 
  32.         //处理网络数据的状态 
  33.         // Expect 100 Continue support 
  34.         req := w.req 
  35.         if req.expectsContinue() { 
  36.             if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 { 
  37.                 // Wrap the Body reader with one that replies on the connection 
  38.                 req.Body = &expectContinueReader{readCloser: req.Body, resp: w} 
  39.             } 
  40.         } else if req.Header.get("Expect") != "" { 
  41.             w.sendExpectationFailed() 
  42.             return 
  43.         }  
  44.         c.curReq.Store(w) 
  45.  
  46.         if requestBodyRemains(req.Body) { 
  47.             registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead) 
  48.         } else { 
  49.             if w.conn.bufr.Buffered() > 0 { 
  50.                 w.conn.r.closeNotifyFromPipelinedRequest() 
  51.             } 
  52.             w.conn.r.startBackgroundRead() 
  53.         }  
  54.         //调用serverHandler{c.server}.ServeHTTP(w, w.req) 
  55.         //方法处理请求 
  56.         serverHandler{c.server}.ServeHTTP(w, w.req) 
  57.         w.cancelCtx() 
  58.         if c.hijacked() { 
  59.             return 
  60.         } 
  61.         w.finishRequest() 
  62.         if !w.shouldReuseConnection() { 
  63.             if w.requestBodyLimitHit || w.closedRequestBodyEarly() { 
  64.                 c.closeWriteAndWait() 
  65.             } 
  66.             return 
  67.         } 
  68.         c.setState(c.rwc, StateIdle) 
  69.         c.curReq.Store((*response)(nil)) 
  70.  
  71.         if !w.conn.server.doKeepAlives() { 
  72.             return 
  73.         } 
  74.  
  75.         if d := c.server.idleTimeout(); d != 0 { 
  76.             c.rwc.SetReadDeadline(time.Now().Add(d)) 
  77.             if _, err := c.bufr.Peek(4); err != nil { 
  78.                 return 
  79.             } 
  80.         } 
  81.         c.rwc.SetReadDeadline(time.Time{}) 
  82.     } 

③处理请求,返回结果

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


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

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


  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. }
  16. func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) { 
  17.     if r.Method != "CONNECT" { 
  18.         if p := cleanPath(r.URL.Path); p != r.URL.Path { 
  19.             _, pattern = mux.handler(r.Host, p) 
  20.             url := *r.URL 
  21.             url.Path = p 
  22.             return RedirectHandler(url.String(), StatusMovedPermanently), pattern 
  23.         } 
  24.     } 
  25.     return mux.handler(r.Host, r.URL.Path) 
  26. }  
  27. func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) { 
  28.     mux.mu.RLock() 
  29.     defer mux.mu.RUnlock() 
  30.  
  31.     // Host-specific pattern takes precedence over generic ones 
  32.     if mux.hosts { 
  33.         //如 127.0.0.1/hello 
  34.         h, pattern = mux.match(host + path) 
  35.     } 
  36.     if h == nil { 
  37.         // 如  /hello 
  38.         h, pattern = mux.match(path) 
  39.     } 
  40.     if h == nil { 
  41.         h, pattern = NotFoundHandler(), "" 
  42.     } 
  43.     return 
  44. }  
  45. func (mux *ServeMux) match(path string) (h Handler, pattern string) { 
  46.     var n = 0 
  47.     for k, v := range mux.m { 
  48.         if !pathMatch(k, path) { 
  49.             continue 
  50.         } 
  51.       //通过迭代m寻找出注册路由的patten模式 
  52.       //与实际url匹配的handler函数并返回。 
  53.         if h == nil || len(k) > n { 
  54.             n = len(k) 
  55.             h = v.h 
  56.             pattern = v.pattern 
  57.         } 
  58.     } 
  59.     return 
  60. func pathMatch(pattern, path string) bool { 
  61.     if len(pattern) == 0 { 
  62.         // should not happen 
  63.         return false 
  64.     } 
  65.     n := len(pattern) 
  66.         //如果注册模式与请求uri一样返回true,否则false 
  67.     if pattern[n-1] != '/' { 
  68.         return pattern == path 
  69.     } 
  70.         //静态文件匹配 
  71.     return len(path) >= n && path[0:n] == pattern 

将数据写给客户端


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

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

总结

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

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

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

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

Go语言HTTP Server源码分析



作者:佚名

来源:51CTO

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Go 语言入门很简单:时间包
时间和日期对于任何编程语言来说都是一个非常重要的包。 GO 语言 提供了 time 包来测量和显示时间。既可以根据所选时区获取当前时间,又可以使用 time 包添加当前时区的持续时间等。
59 0
Go 语言入门很简单:Go 计时器
一般来说,很多时候我们面临这样一种情况,即我们需要运行时间记录器,它不断向我们显示当前时间或在给定的时间间隔内保持执行一定的代码和平,在这种情况下,我们应该使用 Ticker,使用这个我们需要使用 go 语言的 time 包,我们有一个名为 NewTicker() 的方法,它允许我们停止和启动时间代码,我们需要通过传递 chan 和 bool 作为将使用的参数来创建一个代码通道检查它是否打开,如果通道打开意味着计时器将继续。
31 0
Go 语言入门很简单:String
Go 也像 C 语言家族语言一样,使用双引号来声明字符串。 Go 字符串可以使用 双引号(" ")或者 反引号(` `)来创建。双引号用来创建可解析的字符串,但不能用来引用多行,这也是大多数字符串的定义方式。 反引号用来创建原生的字符串,这些字符串可以由多行组成。多用于多行消息,HTML 以及正则表达式。
39 0
Go 语言入门很简单:基准测试
Go 测试包包含一个基准测试工具,用于检查我们的 Go 代码的性能。 在本文中,我们将使用基准工具来逐步提高一段代码的性能。 然后,我们将讨论先进的基准测试技术,以确保我们测量的是正确的东西。
46 0
Go 语言入门很简单:读写锁(上)
这一篇文章我们来介绍 Go 语言帮我们实现的标准库的 sync.RWMutex{} 读写锁。
44 0
go语言简单入门
go语言简单入门
49 0
Go 语言入门很简单 -- 17. Go Package #私藏项目实操分享#
Go 语言入门很简单 -- 17. Go Package #私藏项目实操分享#
69 0
Go 语言入门很简单 -- 16. Go 并发互斥锁 #私藏项目实操分享#
Go 语言入门很简单 -- 16. Go 并发互斥锁 #私藏项目实操分享#
72 0
Go 语言入门很简单 -- 14. Go 并发初识 #私藏项目实操分享#
Go 语言入门很简单 -- 14. Go 并发初识 #私藏项目实操分享#
66 0
Go 语言入门很简单 -- 11. Go 结构体 #私藏项目实操分享#
Go 语言入门很简单 -- 11. Go 结构体 #私藏项目实操分享#
47 0
+关注
行者武松
杀人者,打虎武松也。
文章
问答
文章排行榜
最热
最新
相关电子书
更多
gohbase :HBase go客户端
立即下载
RocketMQ Client-GO 介绍
立即下载
基于 OpenResty 和 Node.js 的个推微服务实践
立即下载