深入理解Golang之http server的實現(xiàn)
前言
對于Golang來說，實現(xiàn)一個簡單的 http server 非常容易，只需要短短幾行代碼。同時有了協(xié)程的加持，Go實現(xiàn)的 http server 能夠取得非常優(yōu)秀的性能。這篇文章將會對go標準庫 net/http 實現(xiàn)http服務的原理進行較為深入的探究，以此來學習了解網(wǎng)絡編程的常見范式以及設計思路。
HTTP服務
基于HTTP構建的網(wǎng)絡應用包括兩個端，即客戶端( Client )和服務端( Server )。兩個端的交互行為包括從客戶端發(fā)出 request 、服務端接受 request 進行處理并返回 response 以及客戶端處理 response 。所以http服務器的工作就在于如何接受來自客戶端的 request ，并向客戶端返回 response 。
典型的http服務端的處理流程可以用下圖表示：
服務器在接收到請求時，首先會進入路由( router )，這是一個 Multiplexer ，路由的工作在于為這個 request 找到對應的處理器( handler )，處理器對 request 進行處理，并構建 response 。Golang實現(xiàn)的 http server 同樣遵循這樣的處理流程。
我們先看看Golang如何實現(xiàn)一個簡單的 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 開啟監(jiān)聽。當有請求過來時，則根據(jù)路由執(zhí)行對應的 handler 函數(shù)。
我們再來看一下另外一種常見的 http server 實現(xiàn)方式：
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實現(xiàn)的 http 服務步驟非常簡單，首先注冊路由，然后創(chuàng)建服務并開啟監(jiān)聽即可。下文我們將從注冊路由、開啟服務、處理請求這幾個步驟了解Golang如何實現(xiàn) http 服務。
注冊路由
http.HandleFunc 和 http.Handle 都是用于注冊路由，可以發(fā)現(xiàn)兩者的區(qū)別在于第二個參數(shù)，前者是一個具有 func(w http.ResponseWriter, r *http.Requests) 簽名的函數(shù)，而后者是一個結構體，該結構體實現(xiàn)了 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)
}
可以看到這兩個函數(shù)最終都由 DefaultServeMux 調用 Handle 方法來完成路由的注冊。
這里我們遇到兩種類型的對象： ServeMux 和 Handler ，我們先說 Handler 。
Handler
Handler 是一個接口：
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
Handler 接口中聲明了名為 ServeHTTP 的函數(shù)簽名，也就是說任何結構只要實現(xiàn)了這個 ServeHTTP 方法，那么這個結構體就是一個 Handler 對象。其實go的 http 服務都是基于 Handler 進行處理，而 Handler 對象的 ServeHTTP 方法也正是用以處理 request 并構建 response 的核心邏輯所在。
回到上面的 HandleFunc 函數(shù)，注意一下這行代碼：
mux.Handle(pattern, HandlerFunc(handler))
可能有人認為 HandlerFunc 是一個函數(shù)，包裝了傳入的 handler 函數(shù)，返回了一個 Handler 對象。然而這里 HandlerFunc 實際上是將 handler 函數(shù)做了一個 類型轉換 ，看一下 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) 簽名的函數(shù)類型，并且這種類型實現(xiàn)了 ServeHTTP 方法（在 ServeHTTP 方法中又調用了自身），也就是說這個類型的函數(shù)其實就是一個 Handler 類型的對象。利用這種類型轉換，我們可以將一個 handler 函數(shù)轉換為一個
Handler 對象，而不需要定義一個結構體，再讓這個結構實現(xiàn) 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 也實現(xiàn)了 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 ，當我們沒有創(chuàng)建自定義的 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創(chuàng)建muxEntry對象
e := muxEntry{h: handler, pattern: pattern}
// 向ServeMux的map[string]muxEntry增加新的路由匹配規(guī)則
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 增加給定的路由匹配規(guī)則；然后如果路由表達式以 '/' 結尾，則將對應的 muxEntry 對象加入到 []muxEntry 中，按照路由表達式長度排序。前者很好理解，但后者可能不太容易看出來有什么作用，這個問題后面再作分析。
自定義ServeMux
我們也可以創(chuàng)建自定義的 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 := `<!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() 可以創(chuàng)建一個 ServeMux 實例，之前提到 ServeMux 也實現(xiàn)了 ServeHTTP 方法，因此 mux 也是一個 Handler 對象。對于 ListenAndServe() 方法，如果傳入的 handler 參數(shù)是自定義 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)})
}
這里先創(chuàng)建了一個 Server 對象，傳入了地址和 handler 參數(shù)，然后調用 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 方法中，會初始化監(jiān)聽地址 Addr ，同時調用 Listen 方法設置監(jiān)聽。最后將監(jiān)聽的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) // 創(chuàng)建新的協(xié)程處理請求
}
}
這里隱去了一些細節(jié)，以便了解 Serve 方法的主要邏輯。首先創(chuàng)建一個上下文對象，然后調用 Listener 的 Accept() 等待新的連接建立；一旦有新的連接建立，則調用 Server 的 newConn() 創(chuàng)建新的連接對象，并將連接的狀態(tài)標志為 StateNew ，然后開啟一個新的 goroutine 處理連接請求。
處理連接
我們繼續(xù)探索 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) // 請求處理結束后，將連接狀態(tài)置為空閑
c.curReq.Store((*response)(nil))// 將當前請求置為空
...
}
}
當一個連接建立之后，該連接中所有的請求都將在這個協(xié)程中進行處理，直到連接被關閉。在 serve() 方法中會循環(huán)調用 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 中查找是否有對應的路由規(guī)則存在；如果沒有匹配的路由規(guī)則，則會進行近似匹配。
對于類似 /path1/path2/path3 這樣的路由，如果不能找到精確匹配的路由規(guī)則，那么則會去匹配和當前路由最接近的已注冊的父路由，所以如果路由 /path1/path2/ 已注冊，那么該路由會被匹配，否則繼續(xù)匹配父路由，知道根路由 / 。
由于 []muxEntry 中的 muxEntry 按照路由表達是從長到短排序，所以進行近似匹配時匹配到的路由一定是已注冊父路由中最接近的。
至此，Go實現(xiàn)的 http server 的大致原理介紹完畢！
總結
Golang通過 ServeMux 定義了一個多路器來管理路由，并通過 Handler 接口定義了路由處理函數(shù)的統(tǒng)一規(guī)范，即 Handler 都須實現(xiàn) ServeHTTP 方法；同時 Handler 接口提供了強大的擴展性，方便開發(fā)者通過 Handler 接口實現(xiàn)各種中間件。相信大家閱讀下來也能感受到 Handler 對象在 server 服務的實現(xiàn)中真的無處不在。理解了 server 實現(xiàn)的基本原理，大家就可以在此基礎上閱讀一些第三方的 http server 框架，以及編寫特定功能的中間件。
以上。
參考資料
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。
相關文章
在go中集成postgresql需使用gorm orm,步驟如下：安裝go和postgresql,安裝 gorm：go get -u gorm.io/gorm,配置數(shù)據(jù)庫連接字符串,定義模型類,遷移數(shù)據(jù)庫架構,使用 gorm 進行增刪改查操作,本指南將介紹如何使用 GORM（一個廣受歡迎的 ORM）,將PostgreSQL集成到你的Go應用中2024-08-08
這篇文章主要介紹了Go泛型應用工廠方法及泛型使用，結合工廠方法+泛型方法來看一下泛型到底是如何在業(yè)務場景中使用的，需要的小伙伴可以參考一下2022-07-07
這篇文章主要為大家介紹了go sync Once實現(xiàn)原理示例解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-01-01
Go語言規(guī)范context?類型的key用法示例解析
這篇文章主要為大家介紹了Go語言規(guī)范context?類型的key用法示例解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-08-08
這篇文章主要介紹了Golang 并發(fā)以及通道的使用方式，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-03-03
使用?gomonkey?Mock?函數(shù)及方法示例詳解
在 Golang 語言中，寫單元測試的時候，不可避免的會涉及到對其他函數(shù)及方法的 Mock，即在假設其他函數(shù)及方法響應預期結果的同時，校驗被測函數(shù)的響應是否符合預期，這篇文章主要介紹了使用?gomonkey?Mock?函數(shù)及方法,需要的朋友可以參考下2022-06-06
本文將介紹如何使用Go語言封裝二級認證功能,實現(xiàn)簡單高效的用戶認證流程,二級認證是一種安全措施,要求用戶在登錄后進行額外的身份驗證,以提高賬戶安全性,2023-10-10
Go官方提供了database包，database包下有sql/driver。該包用來定義操作數(shù)據(jù)庫的接口，這保證了無論使用哪種數(shù)據(jù)庫，操作方式都是相同的。本文就來和大家聊聊Go語言如何操作MYSQL實現(xiàn)CRUD，希望對大家有所幫助2023-02-02
Golang實現(xiàn)CronJob(定時任務)的方法詳解
這篇文章主要為大家詳細介紹了Golang如何通過一個單 pod 去實現(xiàn)一個常駐服務，去跑定時任務（CronJob），文中的示例代碼講解詳細，需要的可以參考下2023-04-04
在Go語言中,你可以使用一些工具來混淆JavaScript代碼,一個常用的工具是Terser,它可以用于壓縮和混淆JavaScript代碼,你可以通過Go語言的`os/exec`包來調用Terser工具,本文給通過一個簡單的示例給大家介紹一下,感興趣的朋友可以參考下2024-01-01