net/http 库的客户端实现(下)

一江溪水

已于 2022-12-24 17:39:01 修改

阅读量926

点赞数 1

分类专栏： Golang 文章标签： http 网络协议 go net/http

于 2022-12-24 16:06:40 首次发布

本文链接：https://blog.csdn.net/upstream480/article/details/128429174

版权

Golang 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

前言

上一篇文章我们讲了 net/http 库客户端 request 的构建，接下来继续讲构建HTTP请求之后的处理操作

net/http 库的客户端实现(上)

net/http 库的客户端实现(下)

net/http 库的服务端实现

启动事务

构建 HTTP 请求后，接着需要开启HTTP事务进行请求并且等待远程响应，以net/http.Client.Do()方法为例子，理一下它的调用链路：

net/http.Client.Do()
net/http.Client.do()
net/http.Client.send()
net/http.Send()
net/http.Transport.RoundTrip()

RoundTrip()是RoundTripper类型中的一个的方法，net/http.Transport是其中的一个实现，可以在net/http/transport.go文件中找到这个方法，看一下源码。

func (t *Transport) roundTrip(req *Request) (*Response, error) {
	// 省略

	for {
		// 检测 ctx 退出信号
		select {
		case <-ctx.Done():
			req.closeBody()
			return nil, ctx.Err()
		default:
		}

		// 获取连接，通过使用连接池对资源进行了复用；
		pconn, err := t.getConn(treq, cm)
		if err != nil {
			t.setReqCanceler(cancelKey, nil)
			req.closeBody()
			return nil, err
		}

		var resp *Response
		if pconn.alt != nil {
			// HTTP/2 path.
			t.setReqCanceler(cancelKey, nil) // not cancelable with CancelRequest
			resp, err = pconn.alt.RoundTrip(req)
		} else {
			// 处理响应
			resp, err = pconn.roundTrip(treq)
		}
		if err == nil {
			resp.Request = origReq
			return resp, nil
		}

		// Rewind the body if we're able to.
		req, err = rewindBody(req)
		if err != nil {
			return nil, err
		}
	}
}

重点看两部分

net/http.Transport.getConn()获取连接
net/http.persistConn.roundTrip()处理写入 HTTP 请求，并在select中等待响应的返回

获取连接(getConn)

func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {
 req := treq.Request
 trace := treq.trace
 ctx := req.Context()
 if trace != nil && trace.GetConn != nil {
  trace.GetConn(cm.addr())
 }

 w := &wantConn{
  cm:         cm,
  key:        cm.key(),
  ctx:        ctx,
  ready:      make(chan struct{}, 1),
  beforeDial: testHookPrePendingDial,
  afterDial:  testHookPostPendingDial,
 }
 defer func() {
  if err != nil {
   w.cancel(t, err)
  }
 }()

 // 在队列中有闲置连接，直接返回
 if delivered := t.queueForIdleConn(w); delivered {
  pc := w.pc
  return pc, nil
 }

 cancelc := make(chan error, 1)
 t.setReqCanceler(treq.cancelKey, func(err error) { cancelc <- err })

 // 放到队列中等待建立新的连接
 t.queueForDial(w)

 // 阻塞等待连接
 select {
 case <-w.ready:
  return w.pc, w.err
 case <-req.Cancel:
  return nil, errRequestCanceledConn
 case <-req.Context().Done():
  return nil, req.Context().Err()
 case err := <-cancelc:
  if err == errRequestCanceled {
   err = errRequestCanceledConn
  }
  return nil, err
 }
}

因为连接的建议会消耗比较多的时间，带来较大的开下，所以Go语言使用了连接池对资源进行分配和复用，先调用 net/http.Transport.queueForIdleConn() 获取等待闲置的连接，如果没有获取到在调用net/http.Transport.queueForDial 在队列中等待建立新的连接，通过select监听连接是否建立完毕，超时未获取到连接会上剖错误，我们继续在queueForDial追踪TCP连接的建立：

启动一个goroutine做tcp的建连，最终调用dialConn方法，在这个方法内做持久化连接，调用net库的dial方法进行TCP连接：

在连接建立后，代码中我们我们还看到分别启动了两个goroutine，

readLoop用于从tcp连接中读取数据，
writeLoop用于从tcp连接中写入数据；

writeLoop方法监听writech通道，在循环中写入发送的数据。

net/http.Transport{}中提供了连接池配置参数，可以自定义

处理 HTTP 请求

net/http.persistConn.roundTrip() 处理HTTP请求

有两个通道：

pc.writech ：其类型是chan writeRequest ，writeLoop协程会循环写入数据，net/http.Request.write会根据net/http.Request结构中的字段按照HTTP协议组成TCP数据段，TCP协议栈会负责将HTTP请求中的内容发送到目标服务器上；
pc.reqch：其类型是chan requestAndChan，readLoop协程会循环读取响应数据并且调用net/http.ReadResponse进行协议解析，其中包含状态码、协议版本、请求头等内容；