【簡單的HTTP伺服器】

原始檔server.go中 ListenAndServe()函式的註釋中有個簡單的HTTP服務實現程式碼，如下

package main
 
import (
	"io"
	"log"
	"net/http"
)
 
func HelloServer(w http.ResponseWriter, r *http.Request) {
	io.WriteString(w, "hello ,this is from HelloServer func ")
}
 
func main() {
	http.HandleFunc("/hello", HelloServer)
	log.Fatal(http.ListenAndServe(":12345", nil))
}
 

【func (srv *Server) Serve(l net.Listener) 方法】

之前有梳理過http.ListenAndServe() 最終會呼叫 Server型別的Serve()方法。再看下其原始碼如下  net/http/server.go 中

2678 func (srv *Server) Serve(l net.Listener) error {
2679         defer l.Close()
2680         if fn := testHookServerServe; fn != nil {
2681                 fn(srv, l)
2682         }
2683         var tempDelay time.Duration // how long to sleep on accept failure
2684 
2685         if err := srv.setupHTTP2_Serve(); err != nil {
2686                 return err
2687         }
2688 
2689         srv.trackListener(l, true)
2690         defer srv.trackListener(l, false)
2691 
2692         baseCtx := context.Background() // base is always background, per Issue 16220
2693         ctx := context.WithValue(baseCtx, ServerContextKey, srv)
2694         for {
2695                 rw, e := l.Accept()
2696                 if e != nil {
2697                         select {
2698                         case <-srv.getDoneChan():
2699                                 return ErrServerClosed
2700                         default:
2701                         }
2702                         if ne, ok := e.(net.Error); ok && ne.Temporary() {
2703                                 if tempDelay == 0 {
2704                                         tempDelay = 5 * time.Millisecond
2705                                 } else {
2706                                         tempDelay *= 2
2707                                 }
2708                                 if max := 1 * time.Second; tempDelay > max {
2709                                         tempDelay = max
2710                                 }
2711                                 srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
2712                                 time.Sleep(tempDelay)
2713                                 continue
2714                         }
2715                         return e
2716                 }
2717                 tempDelay = 0
2718                 c := srv.newConn(rw)
2719                 c.setState(c.rwc, StateNew) // before Serve can return
2720                 go c.serve(ctx)
2721         }
2722 }
 

第2683行定義了一個 time.Duration 型別的區域性變數，用於控制 accept失敗後的等待時間。後續的select語句會用到。

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

2689         srv.trackListener(l, true)
2690         defer srv.trackListener(l, false)

原始碼如下，呼叫了Server型別的trackListener()方法，私有函式，用於對 *Server 資料的併發保護，s.listeners為Server型別的成員變數，型別是一個map，key為 net.Listener ,value為 Struce{}。 Server 型別可以是零值的，所以在使用listeners 成員的時候 要做個nil的判斷，通過make()內建函式初始化。

2767 func (s *Server) trackListener(ln net.Listener, add bool) {
2768         s.mu.Lock()
2769         defer s.mu.Unlock()
2770         if s.listeners == nil {
2771                 s.listeners = make(map[net.Listener]struct{})
2772         }
2773         if add {
2774                 // If the *Server is being reused after a previous
2775                 // Close or Shutdown, reset its doneChan:
2776                 if len(s.listeners) == 0 && len(s.activeConn) == 0 {
2777                         s.doneChan = nil
2778                 }
2779                 s.listeners[ln] = struct{}{}
2780         } else {
2781                 delete(s.listeners, ln)
2782         }
2783 }

接下來的for迴圈，原始碼如下

2694         for {
2695                 rw, e := l.Accept()
2696                 if e != nil {
2697                         select {
2698                         case <-srv.getDoneChan():
2699                                 return ErrServerClosed
2700                         default:
2701                         }
2702                         if ne, ok := e.(net.Error); ok && ne.Temporary() {
2703                                 if tempDelay == 0 {
2704                                         tempDelay = 5 * time.Millisecond
2705                                 } else {
2706                                         tempDelay *= 2
2707                                 }
2708                                 if max := 1 * time.Second; tempDelay > max {
2709                                         tempDelay = max
2710                                 }
2711                                 srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
2712                                 time.Sleep(tempDelay)
2713                                 continue
2714                         }
2715                         return e
2716                 }
2717                 tempDelay = 0
2718                 c := srv.newConn(rw)
2719                 c.setState(c.rwc, StateNew) // before Serve can return
2720                 go c.serve(ctx)

主要做了5件事情

• 通過Accept() 監聽請求
• Accpet錯誤處理
• 通過Server型別的newConn方法構建 conn型別資料（小寫c）
• 設定conn狀態
• 併發執行conn

1、l.Accept() 預設是執行net.Listener 介面的 Accept() 方法，即： Accept() (Conn, error)

     之前梳理 ListenAndServe的時候，有個tcpKeepAliveListener 型別的資料，重新實現了Accept方法，增加了超時時間的設定。

2、通過select語句實現錯誤等待。case阻塞後，會執行default語句。通過Temporary()簡單判斷 

3、 c := srv.newConn(rw) 中 newConn()方法程式碼如下，構造conn型別。

func (srv *Server) newConn(rwc net.Conn) *conn {
        c := &conn{
                server: srv, 
                rwc:    rwc, 
        }    
        if debugServerConnections {
                c.rwc = newLoggingConn("server", c.rwc)
        }    
        return c
}
  conn型別為server.go 中的私有型別，較複雜，需要了解的直接看原始碼

4、c.setState(c.rwc, StateNew) 設定conn的狀態，setState()原始碼如下，根據引數state的值來設定狀態

1634 func (c *conn) setState(nc net.Conn, state ConnState) {
1635         srv := c.server
1636         switch state {
1637         case StateNew:
1638                 srv.trackConn(c, true)
1639         case StateHijacked, StateClosed:
1640                 srv.trackConn(c, false)
1641         }
1642         c.curState.Store(connStateInterface[state])
1643         if hook := srv.ConnState; hook != nil {
1644                 hook(nc, state)
1645         }
1646 }

引數state的數值如下:

var stateName = map[ConnState]string{
        StateNew:      "new",
        StateActive:   "active",
        StateIdle:     "idle",
        StateHijacked: "hijacked",
        StateClosed:   "closed",

5、go c.serve(ctx)併發執行 請求。其原型如下 func (c *conn) serve(ctx context.Context)。原始碼邏輯較複雜，我們值關注下面這行，即 ServeHTTP(w, w.req)。

1794                 // HTTP cannot have multiple simultaneous active requests.[*]
1795                 // Until the server replies to this request, it can't read another,
1796                 // so we might as well run the handler in this goroutine.
1797                 // [*] Not strictly true: HTTP pipelining. We could let them all process
1798                 // in parallel even if their responses need to be serialized.
1799                 // But we're not going to implement HTTP pipelining because it
1800                 // was never deployed in the wild and the answer is HTTP/2.
1801                 serverHandler{c.server}.ServeHTTP(w, w.req)

回到開始的例子，HelloServer(w http.ResponseWriter, r *http.Request) 的簽名與 ServeHTTP(w, w.req)是一致的.即 ListerAndServe → Server.Serve() → conn.serve  最後執行  ServeHTTP(w, w.req) 簽名格式的邏輯，在本例中就是HelloServer自定義函式。最終HTTP的通訊通過Request 和Response 來實現。