登录
首页 >  Golang >  Go教程

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

来源:脚本之家

时间:2022-12-29 09:17:05 419浏览 收藏

知识点掌握了,还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战,手把手教大家学习《一文详解Golang中net/http包的实现原理》,在实现功能的过程中也带大家重新温习相关知识点,温故而知新,回头看看说不定又有不一样的感悟!

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  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用于管理这些生成的goroutinecontext作为参数被传入;

请求解析

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

函数代码比较多,就不贴出来了,具体可以到/net/http/server.go文件中查看,其中使用了defer func() {...}()匿名函数来实现错误输入和恢复、连接关闭;

该方法用于服务一个新的连接。首先,通过readRequest来读取数据,解析请求中的HeaderBody和一些校验。接着,使用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学习网公众号下多多回复交流;文中若有不正之处,也希望回复留言以告知!

声明:本文转载于:脚本之家 如有侵犯,请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>
评论列表