一文详解Golang中net/http包的实现原理

前言

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

来源：https://juejin.cn/post/7127535913483108360