您现在的位置是：网站首页> 编程资料编程资料

深入理解Golang之http server的实现_Golang_

2023-05-26 391人已围观

简介 深入理解Golang之http server的实现_Golang_

前言

对于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 main import ( "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 main import ( "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 main import ( "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 := `Golang
Welcome!
` 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 ato
                
                

                

                                            
上一篇：如何在Go中使用切片容量和长度_Golang_

                                                                
下一篇：golang执行命令获取执行结果状态(推荐)_Golang_

相关内容

点击排行

本栏推荐

猜你喜欢

-六神源码网