一文詳解Golang中net/http包的實現原理

2022-08-03 22:03:20

前言

Go語言自帶的net/http包提供了HTTP使用者端和伺服器端的實現，實現一個簡單的http服務非常容易，其自帶了一些列結構和方法來幫助開發者簡化HTTP服務開發的相關流程，因此我們不需要依賴任何第三方元件就能構建並啟動一個高並行的HTTP伺服器，net/http包在編寫web應用中有很重要的作用，這篇文章會學習如何用 net/http 自己編寫實現一個 HTTP Server 並探究其實現原理，具體講解Go語言是如何接收和處理請求的，希望能夠對大家的學習或工作具有一定的幫助,需要的朋友可以參考下。

http包執行流程

net/http包的web工作原理大致就是如下四個部分組成了：埠監聽、請求解析、路由分配、響應處理。更加程式碼化的說就是：建立 ServerSocket，繫結並listen，accept連線，建立go協程服務一個連線。

具體流程如下：

伺服器端建立Listen Socket，繫結並監聽指定的IP地址和埠，等待使用者端請求到來； ListenAndServer(...)
使用者端與Listen Socket連線，確認請求後，使用者端得到Client Socket,使用者端通過這個與Listen Socket 通訊；srv.Server(...)
伺服器端建立一個協程來處理使用者端請求，首先從Client Socket讀取Http請求的協定頭和資料，交給響應的Handler處理，
Handler處理完畢後，結果通過Client Socket寫給使用者端。c.server(...)

http包原始碼分析

在上面的流程中中，起關鍵作用的函數為http.ListenAndServe，Go就是利用這個方法，實現了web服務中的埠監聽、請求解析、路由分配、響應處理四大功能。

埠監聽

伺服器中的http.ListenAndServer()方法啟動服務：

func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}

生成Server結構體，呼叫其方法ListenAndServer

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

net.Listen來進行對地址的監聽，返回一個listener,傳遞給server.Server()方法。

func (srv *Server) Serve(l net.Listener) error {
	if fn := testHookServerServe; fn != nil {
		fn(srv, l) // call hook with unwrapped listener
	}

	origListener := l
	l = &onceCloseListener{Listener: l}
	defer l.Close()

	if err := srv.setupHTTP2_Serve(); err != nil {
		return err
	}

	if !srv.trackListener(&l, true) {
		return ErrServerClosed
	}
	defer srv.trackListener(&l, false)

	baseCtx := context.Background()
	if srv.BaseContext != nil {
		baseCtx = srv.BaseContext(origListener)
		if baseCtx == nil {
			panic("BaseContext returned a nil context")
		}
	}

	var tempDelay time.Duration // how long to sleep on accept failure

	ctx := context.WithValue(baseCtx, ServerContextKey, srv)
	for { //迴圈邏輯，接收請求處理
          //有新的連線
		rw, err := l.Accept()
		if err != nil {
			select {
			case <-srv.getDoneChan():
				return ErrServerClosed
			default:
			}
			if ne, ok := err.(net.Error); ok && ne.Temporary() {
				if tempDelay == 0 {
					tempDelay = 5 * time.Millisecond
				} else {
					tempDelay *= 2
				}
				if max := 1 * time.Second; tempDelay > max {
					tempDelay = max
				}
				srv.logf("http: Accept error: %v; retrying in %v", err, tempDelay)
				time.Sleep(tempDelay)
				continue
			}
			return err
		}
		connCtx := ctx
		if cc := srv.ConnContext; cc != nil {
			connCtx = cc(connCtx, rw)
			if connCtx == nil {
				panic("ConnContext returned nil")
			}
		}
		tempDelay = 0
        //建立新的連線
		c := srv.newConn(rw)
		c.setState(c.rwc, StateNew) // before Serve can return
        //啟動新的goroutine進行處理
		go c.serve(connCtx)
	}
}

主要進行了兩項工作，一項是在for死迴圈裡面，通過l.Accept()來接受請求返回連線Conn，並處理相關的報錯，根據該連線建立對應的goroutine來執行conn.serve(ctx)，各個請求之間是相互不影響的，提高並行效能。另一項工作是新建context用於管理這些生成的goroutine，context作為引數被傳入；

請求解析

// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
    // ...
}

函數程式碼比較多，就不貼出來了，具體可以到/net/http/server.go檔案中檢視，其中使用了defer func() {...}()匿名函數來實現錯誤輸入和恢復、連線關閉；

該方法用於服務一個新的連線。首先，通過readRequest來讀取資料，解析請求中的Header、Body和一些校驗。接著，使用serverHandler方法來處理request和response。主要功能實現是serverHandler{c.server}.ServeHTTP(w, w.req)，其構造serverHandler型別，並呼叫ServeHTTP方法；值得注意的是，這裡不允許伺服器同時處理多個請求；

路由分配

使用者註冊一個HandlerFunc，被轉為Handler

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

ServeMux的Handle方法，將會對pattern和Handler做map對映。

handler會建立一個鎖，同時呼叫match方法返回一個Handler和pattern。

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)
	}
	e := muxEntry{h: handler, pattern: pattern}
	mux.m[pattern] = e
	if pattern[len(pattern)-1] == '/' {
		mux.es = appendSorted(mux.es, e)
	}

	if pattern[0] != '/' {
		mux.hosts = true
	}
}

響應處理

其實就是如何根據路由，找到對應的handler。

在match方法中，對於handler，優先查詢m表，若不能找到結果，則在es表中進行匹配，路徑長的優先匹配。

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.
	var n = 0
	for k, v := range mux.m {
		if !pathMatch(k, path) {
			continue
		}
		if h == nil || len(k) > n {
			n = len(k)
			h = v.h
			pattern = v.pattern
		}
	}
	return
}

伺服器端處理完請求後，處理器可以通過ResponseWriter介面建立HTTP響應，ResponseWriter介面具有如下三個方法：

type ResponseWriter interface {
	Header() Header
	Write([]byte) (int, error)
	WriteHeader(statusCode int)
}

到此這篇關於一文詳解Golang中net/http包的實現原理的文章就介紹到這了,更多相關Golang net http包內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！