侯体宗的博客
  • 首页
  • Hyperf版
  • beego仿版
  • 人生(杂谈)
  • 技术
  • 关于我
  • 更多分类
    • 文件下载
    • 文字修仙
    • 中国象棋ai
    • 群聊
    • 九宫格抽奖
    • 拼图
    • 消消乐
    • 相册

深入理解Golang之http server的实现

Go  /  管理员 发布于 7年前   145

前言

对于Golang来说,实现一个简单的 http server 非常容易,只需要短短几行代码。同时有了协程的加持,Go实现的 http server 能够取得非常优秀的性能。这篇文章将会对go标准库 net/http 实现http服务的原理进行较为深入的探究,以此来学习了解网络编程的常见范式以及设计思路。

HTTP服务

基于HTTP构建的网络应用包括两个端,即客户端( Client )和服务端( Server )。两个端的交互行为包括从客户端发出 request 、服务端接受 request 进行处理并返回 response 以及客户端处理 response 。所以http服务器的工作就在于如何接受来自客户端的 request ,并向客户端返回 response 。

典型的http服务端的处理流程可以用下图表示:

服务器在接收到请求时,首先会进入路由( router ),这是一个 Multiplexer ,路由的工作在于为这个 request 找到对应的处理器( handler ),处理器对 request 进行处理,并构建 response 。Golang实现的 http server 同样遵循这样的处理流程。

我们先看看Golang如何实现一个简单的 http server :

package mainimport ( "fmt" "net/http")func indexHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "hello world")}func main() { http.HandleFunc("/", indexHandler) http.ListenAndServe(":8000", nil)}

运行代码之后,在浏览器中打开 localhost:8000 就可以看到 hello world 。这段代码先利用 http.HandleFunc 在根路由 / 上注册了一个 indexHandler , 然后利用 http.ListenAndServe 开启监听。当有请求过来时,则根据路由执行对应的 handler 函数。

我们再来看一下另外一种常见的 http server 实现方式:

package mainimport ( "fmt" "net/http")type indexHandler struct { content string}func (ih *indexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, ih.content)}func main() { http.Handle("/", &indexHandler{content: "hello world!"}) http.ListenAndServe(":8001", nil)}

Go实现的 http 服务步骤非常简单,首先注册路由,然后创建服务并开启监听即可。下文我们将从注册路由、开启服务、处理请求这几个步骤了解Golang如何实现 http 服务。

注册路由

http.HandleFunc 和 http.Handle 都是用于注册路由,可以发现两者的区别在于第二个参数,前者是一个具有 func(w http.ResponseWriter, r *http.Requests) 签名的函数,而后者是一个结构体,该结构体实现了 func(w http.ResponseWriter, r *http.Requests) 签名的方法。

http.HandleFunc 和 http.Handle 的源码如下:

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) { DefaultServeMux.HandleFunc(pattern, handler)}// HandleFunc registers the handler function for the given pattern.func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) { if handler == nil {  panic("http: nil handler") } mux.Handle(pattern, HandlerFunc(handler))}
func Handle(pattern string, handler Handler) {  DefaultServeMux.Handle(pattern, handler)}

可以看到这两个函数最终都由 DefaultServeMux 调用 Handle 方法来完成路由的注册。

这里我们遇到两种类型的对象: ServeMux 和 Handler ,我们先说 Handler 。

Handler

Handler 是一个接口:

type Handler interface { ServeHTTP(ResponseWriter, *Request)}

Handler 接口中声明了名为 ServeHTTP 的函数签名,也就是说任何结构只要实现了这个 ServeHTTP 方法,那么这个结构体就是一个 Handler 对象。其实go的 http 服务都是基于 Handler 进行处理,而 Handler 对象的 ServeHTTP 方法也正是用以处理 request 并构建 response 的核心逻辑所在。

回到上面的 HandleFunc 函数,注意一下这行代码:

mux.Handle(pattern, HandlerFunc(handler))

可能有人认为 HandlerFunc 是一个函数,包装了传入的 handler 函数,返回了一个 Handler 对象。然而这里 HandlerFunc 实际上是将 handler 函数做了一个 类型转换 ,看一下 HandlerFunc 的定义:

type HandlerFunc func(ResponseWriter, *Request)// ServeHTTP calls f(w, r).func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r)}

HandlerFunc 是一个类型,只不过表示的是一个具有 func(ResponseWriter, *Request) 签名的函数类型,并且这种类型实现了 ServeHTTP 方法(在 ServeHTTP 方法中又调用了自身),也就是说这个类型的函数其实就是一个 Handler 类型的对象。利用这种类型转换,我们可以将一个 handler 函数转换为一个

Handler 对象,而不需要定义一个结构体,再让这个结构实现 ServeHTTP 方法。读者可以体会一下这种技巧。

ServeMux

Golang中的路由(即 Multiplexer )基于 ServeMux 结构,先看一下 ServeMux 的定义:

type ServeMux struct { mu sync.RWMutex m  map[string]muxEntry es []muxEntry // slice of entries sorted from longest to shortest. hosts bool  // whether any patterns contain hostnames}type muxEntry struct { h  Handler pattern string}

这里重点关注 ServeMux 中的字段 m ,这是一个 map , key 是路由表达式, value 是一个 muxEntry 结构, muxEntry 结构体存储了对应的路由表达式和 handler 。

值得注意的是, ServeMux 也实现了 ServeHTTP 方法:

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) h.ServeHTTP(w, r)}

也就是说 ServeMux 结构体也是 Handler 对象,只不过 ServeMux 的 ServeHTTP 方法不是用来处理具体的 request 和构建 response ,而是用来确定路由注册的 handler 。

注册路由

搞明白 Handler 和 ServeMux 之后,我们再回到之前的代码:

DefaultServeMux.Handle(pattern, handler)

这里的 DefaultServeMux 表示一个默认的 Multiplexer ,当我们没有创建自定义的 Multiplexer ,则会自动使用一个默认的 Multiplexer 。

然后再看一下 ServeMux 的 Handle 方法具体做了什么:

func (mux *ServeMux) Handle(pattern string, handler Handler) { mux.mu.Lock() defer mux.mu.Unlock() if pattern == "" {  panic("http: invalid pattern") } if handler == nil {  panic("http: nil handler") } if _, exist := mux.m[pattern]; exist {  panic("http: multiple registrations for " + pattern) } if mux.m == nil {  mux.m = make(map[string]muxEntry) } // 利用当前的路由和handler创建muxEntry对象 e := muxEntry{h: handler, pattern: pattern} // 向ServeMux的map[string]muxEntry增加新的路由匹配规则 mux.m[pattern] = e // 如果路由表达式以'/'结尾,则将对应的muxEntry对象加入到[]muxEntry中,按照路由表达式长度排序 if pattern[len(pattern)-1] == '/' {  mux.es = appendSorted(mux.es, e) } if pattern[0] != '/' {  mux.hosts = true }}

Handle 方法主要做了两件事情:一个就是向 ServeMux 的 map[string]muxEntry 增加给定的路由匹配规则;然后如果路由表达式以 '/' 结尾,则将对应的 muxEntry 对象加入到 []muxEntry 中,按照路由表达式长度排序。前者很好理解,但后者可能不太容易看出来有什么作用,这个问题后面再作分析。

自定义ServeMux

我们也可以创建自定义的 ServeMux 取代默认的 DefaultServeMux :

package mainimport ( "fmt" "net/http")func indexHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "hello world")}func htmlHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html") html := `<!doctype html> <META http-equiv="Content-Type" content="text/html" charset="utf-8"> <html lang="zh-CN">   <head>     <title>Golang</title>     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0;" />   </head>   <body>    <div id="app">Welcome!</div>   </body> </html>` fmt.Fprintf(w, html)}func main() { mux := http.NewServeMux() mux.Handle("/", http.HandlerFunc(indexHandler)) mux.HandleFunc("/welcome", htmlHandler) http.ListenAndServe(":8001", mux)}

NewServeMux() 可以创建一个 ServeMux 实例,之前提到 ServeMux 也实现了 ServeHTTP 方法,因此 mux 也是一个 Handler 对象。对于 ListenAndServe() 方法,如果传入的 handler 参数是自定义 ServeMux 实例 mux ,那么 Server 实例接收到的路由对象将不再是 DefaultServeMux 而是 mux 。

开启服务

首先从 http.ListenAndServe 这个方法开始:

func ListenAndServe(addr string, handler Handler) error { server := &Server{Addr: addr, Handler: handler} return server.ListenAndServe()}func (srv *Server) ListenAndServe() error { if srv.shuttingDown() {  return ErrServerClosed } 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)})}

这里先创建了一个 Server 对象,传入了地址和 handler 参数,然后调用 Server 对象 ListenAndServe() 方法。

看一下 Server 这个结构体, Server 结构体中字段比较多,可以先大致了解一下:

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

在 Server 的 ListenAndServe 方法中,会初始化监听地址 Addr ,同时调用 Listen 方法设置监听。最后将监听的TCP对象传入 Serve 方法:

func (srv *Server) Serve(l net.Listener) error { ... baseCtx := context.Background() // base is always background, per Issue 16220 ctx := context.WithValue(baseCtx, ServerContextKey, srv) for {  rw, e := l.Accept() // 等待新的连接建立  ...  c := srv.newConn(rw)  c.setState(c.rwc, StateNew) // before Serve can return  go c.serve(ctx) // 创建新的协程处理请求 }}

这里隐去了一些细节,以便了解 Serve 方法的主要逻辑。首先创建一个上下文对象,然后调用 Listener 的 Accept() 等待新的连接建立;一旦有新的连接建立,则调用 Server 的 newConn() 创建新的连接对象,并将连接的状态标志为 StateNew ,然后开启一个新的 goroutine 处理连接请求。

处理连接

我们继续探索 conn 的 serve() 方法,这个方法同样很长,我们同样只看关键逻辑。坚持一下,马上就要看见大海了。

func (c *conn) serve(ctx context.Context) { ... 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)  }  ...  // 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)  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))// 将当前请求置为空  ... }}

当一个连接建立之后,该连接中所有的请求都将在这个协程中进行处理,直到连接被关闭。在 serve() 方法中会循环调用 readRequest() 方法读取下一个请求进行处理,其中最关键的逻辑就是一行代码:

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

进一步解释 serverHandler :

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

在 serverHandler 的 ServeHTTP() 方法里的 sh.srv.Handler 其实就是我们最初在 http.ListenAndServe() 中传入的 Handler 对象,也就是我们自定义的 ServeMux 对象。如果该 Handler 对象为 nil ,则会使用默认的 DefaultServeMux 。最后调用 ServeMux 的 ServeHTTP() 方法匹配当前路由对应的 handler 方法。

后面的逻辑就相对简单清晰了,主要在于调用 ServeMux 的 match 方法匹配到对应的已注册的路由表达式和 handler 。

// ServeHTTP dispatches the request to the handler whose// pattern most closely matches the request URL.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) h.ServeHTTP(w, r)}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 {  h, pattern = mux.match(host + path) } if h == nil {  h, pattern = mux.match(path) } if h == nil {  h, pattern = NotFoundHandler(), "" } return}// 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 } // Check for longest valid match. mux.es contains all patterns // that end in / sorted from longest to shortest. for _, e := range mux.es {  if strings.HasPrefix(path, e.pattern) {   return e.h, e.pattern  } } return nil, ""}

在 match 方法里我们看到之前提到的 map[string]muxEntry 和 []muxEntry 。这个方法里首先会利用进行精确匹配,在 map[string]muxEntry 中查找是否有对应的路由规则存在;如果没有匹配的路由规则,则会进行近似匹配。

对于类似 /path1/path2/path3 这样的路由,如果不能找到精确匹配的路由规则,那么则会去匹配和当前路由最接近的已注册的父路由,所以如果路由 /path1/path2/ 已注册,那么该路由会被匹配,否则继续匹配父路由,知道根路由 / 。

由于 []muxEntry 中的 muxEntry 按照路由表达是从长到短排序,所以进行近似匹配时匹配到的路由一定是已注册父路由中最接近的。

至此,Go实现的 http server 的大致原理介绍完毕!

总结

Golang通过 ServeMux 定义了一个多路器来管理路由,并通过 Handler 接口定义了路由处理函数的统一规范,即 Handler 都须实现 ServeHTTP 方法;同时 Handler 接口提供了强大的扩展性,方便开发者通过 Handler 接口实现各种中间件。相信大家阅读下来也能感受到 Handler 对象在 server 服务的实现中真的无处不在。理解了 server 实现的基本原理,大家就可以在此基础上阅读一些第三方的 http server 框架,以及编写特定功能的中间件。

以上。

参考资料

【Golang标准库文档--net/http】

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。


  • 上一条:
    golang执行命令获取执行结果状态(推荐)
    下一条:
    golang环形队列实现代码示例
  • 昵称:

    邮箱:

    0条评论 (评论内容有缓存机制,请悉知!)
    最新最热
    • 分类目录
    • 人生(杂谈)
    • 技术
    • linux
    • Java
    • php
    • 框架(架构)
    • 前端
    • ThinkPHP
    • 数据库
    • 微信(小程序)
    • Laravel
    • Redis
    • Docker
    • Go
    • swoole
    • Windows
    • Python
    • 苹果(mac/ios)
    • 相关文章
    • 在go中实现一个常用的先进先出的缓存淘汰算法示例代码(0个评论)
    • 在go+gin中使用"github.com/skip2/go-qrcode"实现url转二维码功能(0个评论)
    • 在go语言中使用api.geonames.org接口实现根据国际邮政编码获取地址信息功能(1个评论)
    • 在go语言中使用github.com/signintech/gopdf实现生成pdf分页文件功能(0个评论)
    • 在go语言中使用github.com/signintech/gopdf实现生成pdf文件功能(0个评论)
    • 近期文章
    • 在go中实现一个常用的先进先出的缓存淘汰算法示例代码(0个评论)
    • 在go+gin中使用"github.com/skip2/go-qrcode"实现url转二维码功能(0个评论)
    • 在go语言中使用api.geonames.org接口实现根据国际邮政编码获取地址信息功能(1个评论)
    • 在go语言中使用github.com/signintech/gopdf实现生成pdf分页文件功能(0个评论)
    • gmail发邮件报错:534 5.7.9 Application-specific password required...解决方案(0个评论)
    • 欧盟关于强迫劳动的规定的官方举报渠道及官方举报网站(0个评论)
    • 在go语言中使用github.com/signintech/gopdf实现生成pdf文件功能(0个评论)
    • Laravel从Accel获得5700万美元A轮融资(0个评论)
    • 在go + gin中gorm实现指定搜索/区间搜索分页列表功能接口实例(0个评论)
    • 在go语言中实现IP/CIDR的ip和netmask互转及IP段形式互转及ip是否存在IP/CIDR(0个评论)
    • 近期评论
    • 122 在

      学历:一种延缓就业设计,生活需求下的权衡之选中评论 工作几年后,报名考研了,到现在还没认真学习备考,迷茫中。作为一名北漂互联网打工人..
    • 123 在

      Clash for Windows作者删库跑路了,github已404中评论 按理说只要你在国内,所有的流量进出都在监控范围内,不管你怎么隐藏也没用,想搞你分..
    • 原梓番博客 在

      在Laravel框架中使用模型Model分表最简单的方法中评论 好久好久都没看友情链接申请了,今天刚看,已经添加。..
    • 博主 在

      佛跳墙vpn软件不会用?上不了网?佛跳墙vpn常见问题以及解决办法中评论 @1111老铁这个不行了,可以看看近期评论的其他文章..
    • 1111 在

      佛跳墙vpn软件不会用?上不了网?佛跳墙vpn常见问题以及解决办法中评论 网站不能打开,博主百忙中能否发个APP下载链接,佛跳墙或极光..
    • 2016-10
    • 2017-09
    • 2020-03
    • 2020-05
    • 2020-06
    • 2020-07
    • 2020-12
    • 2021-01
    • 2021-05
    • 2021-06
    • 2021-07
    • 2021-08
    • 2021-10
    • 2021-11
    • 2021-12
    • 2022-01
    • 2022-02
    • 2022-03
    • 2022-04
    • 2022-05
    • 2022-06
    • 2022-07
    • 2022-08
    • 2022-09
    • 2022-10
    • 2022-11
    • 2022-12
    • 2023-01
    • 2023-02
    • 2023-03
    • 2023-04
    • 2023-05
    • 2023-06
    • 2023-07
    • 2023-08
    • 2023-09
    • 2023-10
    • 2023-11
    • 2023-12
    • 2024-01
    • 2024-02
    • 2024-03
    • 2024-04
    • 2024-05
    • 2024-06
    • 2024-07
    • 2024-08
    • 2024-11
    • 2025-02
    • 2025-04
    • 2025-05
    • 2025-06
    Top

    Copyright·© 2019 侯体宗版权所有· 粤ICP备20027696号 PHP交流群

    侯体宗的博客