图文吃透Golang net/http 标准库--客户端

type Client struct { 
	Transport RoundTripper 
	CheckRedirect func(req *Request, via []*Request) error 
	Jar CookieJar 
	Timeout time.Duration
}

type Request struct {
    Method string
    URL *url.URL
    Header Header
    Body io.ReadCloser
    Host string
    Response *Response
    ...
}

var DefaultClient = &Client{}

func Get(url string) (resp *Response, err error) {
    return DefaultClient.Get(url)
}

func (c *Client) Get(url string) (resp *Response, err error) {
	req, err := NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	return c.Do(req)
}

func NewRequest(method, url string, body io.Reader) (*Request, error) {
	return NewRequestWithContext(context.Background(), method, url, body)
}

func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
	...
	// 解析url
	u, err := urlpkg.Parse(url)
	...
	rc, ok := body.(io.ReadCloser)
	if !ok && body != nil {
		rc = ioutil.NopCloser(body)
	} 
	u.Host = removeEmptyPort(u.Host)
	req := &Request{
		ctx:        ctx,
		Method:     method,
		URL:        u,
		Proto:      "HTTP/1.1",
		ProtoMajor: 1,
		ProtoMinor: 1,
		Header:     make(Header),
		Body:       rc,
		Host:       u.Host,
	} 
	...
	return req, nil
}

func (c *Client) do(req *Request) (retres *Response, reterr error) {
	...
    for {
        ...
        resp, didTimeout, err = send(req, deadline)
    	if err != nil {
    		return nil, didTimeout, err
    	}
    }
	...
}
//Client 调用 Do 方法处理发送请求最后会调用到 send 函数中
func (c *Client) send(req *Request, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
	resp, didTimeout, err = send(req, c.transport(), deadline)
	if err != nil {
		return nil, didTimeout, err
	}
	...
	return resp, nil, nil
}

var DefaultTransport RoundTripper = &Transport{
	Proxy: ProxyFromEnvironment,
	DialContext: defaultTransportDialContext(&net.Dialer{
		Timeout:   30 * time.Second,
		KeepAlive: 30 * time.Second,
	}),
	ForceAttemptHTTP2:     true,
	MaxIdleConns:          100,
	IdleConnTimeout:       90 * time.Second,
	TLSHandshakeTimeout:   10 * time.Second,
	ExpectContinueTimeout: 1 * time.Second,
}

type RoundTripper interface { 
	RoundTrip(*Request) (*Response, error)
}

func send(ireq *Request, rt RoundTripper, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
	...
    resp, err = rt.RoundTrip(req)
	if err != nil {
        ...
    }
    ..
}

func (t *Transport) RoundTrip(req *Request) (*Response, error) {
	return t.roundTrip(req)
}

func (t *Transport) roundTrip(req *Request) (*Response, error) {
	...  
	for {
		...
		// 请求封装
		treq := &transportRequest{Request: req, trace: trace, cancelKey: cancelKey} 
		cm, err := t.connectMethodForRequest(treq)
		if err != nil {
			...
		} 
		// 获取连接
		pconn, err := t.getConn(treq, cm)
		if err != nil {
    		...
		}
		
		// 等待响应结果
		var resp *Response
		if pconn.alt != nil {
			t.setReqCanceler(cancelKey, nil) 
			resp, err = pconn.alt.RoundTrip(req)
		} else {
			resp, err = pconn.roundTrip(treq)
		}
		...
	}
}

func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {
	...
	//  初始化wantConn结构体
	w := &wantConn{
		cm:         cm,
		key:        cm.key(),
		ctx:        ctx,
		ready:      make(chan struct{}, 1),
		beforeDial: testHookPrePendingDial,
		afterDial:  testHookPostPendingDial,
	}
	...
	// 获取空闲连接
	if delivered := t.queueForIdleConn(w); delivered {
		...
	}
 
	// 异步创建新连接
	t.queueForDial(w)
 
	select {
	// 阻塞等待获取到连接完成
	case <-w.ready:
		...
		return w.pc, w.err
	...
}

//idleConn是map类型，指定key返回切片列表
idleConn     map[connectMethodKey][]*persistConn 
//idleConnWait，指定key返回队列
idleConnWait map[connectMethodKey]wantConnQueue

func (t *Transport) queueForIdleConn(w *wantConn) (delivered bool) {
	//参数判断
    if t.DisableKeepAlives {
		return false
	}

	if w == nil { 
		return false
	}
 
	// 计算空闲连接超时时间
	var oldTime time.Time
	if t.IdleConnTimeout > 0 {
		oldTime = time.Now().Add(-t.IdleConnTimeout)
	}
	//从idleConn根据w.key找对应的persistConn 列表
	if list, ok := t.idleConn[w.key]; ok {
		stop := false
		delivered := false
		for len(list) > 0 && !stop {
			// 找到persistConn列表最后一个
			pconn := list[len(list)-1] 
			// 检查这个 persistConn 是不是过期
			tooOld := !oldTime.IsZero() && pconn.idleAt.Round(0).Before(oldTime)
			if tooOld {
                //如果过期进行异步清理
				go pconn.closeConnIfStillIdle()
			}
			// 该 persistConn 被标记为 broken 或 闲置太久 continue
			if pconn.isBroken() || tooOld { 
				list = list[:len(list)-1]
				continue
			}
			// 尝试将该 persistConn 写入到 wantConn（w）中
			delivered = w.tryDeliver(pconn, nil)
			if delivered {
				// 写入成功，将persistConn从空闲列表中移除
				if pconn.alt != nil { 
				} else { 
					t.idleLRU.remove(pconn)
                    //缺省了最后一个conn
					list = list[:len(list)-1]
				}
			}
			stop = true
		}
        //对被获取连接后的列表进行判断
		if len(list) > 0 {
			t.idleConn[w.key] = list
		} else {
			// 如果该 key 对应的空闲列表不存在，那么将该key从字典中移除
			delete(t.idleConn, w.key)
		}
		if stop {
			return delivered
		}
	} 
	// 如果找不到空闲的 persistConn
	if t.idleConnWait == nil {
		t.idleConnWait = make(map[connectMethodKey]wantConnQueue)
	}
    // 将该 wantConn添加到等待空闲idleConnWait中
	q := t.idleConnWait[w.key] 
	q.cleanFront()
	q.pushBack(w)
	t.idleConnWait[w.key] = q
	return false
}

// waiting getConns
idleConnWait map[connectMethodKey]wantConnQueue 
// waiting getConns
connsPerHostWait map[connectMethodKey]wantConnQueue

func (t *Transport) queueForDial(w *wantConn) {
	w.beforeDial()
    // 小于等于零，意思是限制，直接异步建立连接
	if t.MaxConnsPerHost <= 0 {
		go t.dialConnFor(w)
		return
	}
    ...
    //host建立的连接数没达到上限，执行异步建立连接
	if n := t.connsPerHost[w.key]; n < t.MaxConnsPerHost {
		if t.connsPerHost == nil {
			t.connsPerHost = make(map[connectMethodKey]int)
		}
		t.connsPerHost[w.key] = n + 1
		go t.dialConnFor(w)
		return
	}
    //进入等待队列
	if t.connsPerHostWait == nil {
		t.connsPerHostWait = make(map[connectMethodKey]wantConnQueue)
	}
	q := t.connsPerHostWait[w.key]
	q.cleanFront()
	q.pushBack(w)
	t.connsPerHostWait[w.key] = q
}

func (t *Transport) dialConnFor(w *wantConn) {
	defer w.afterDial()
    //创建 persistConn
	pc, err := t.dialConn(w.ctx, w.cm)
    //绑定到 wantConn
	delivered := w.tryDeliver(pc, err)
	if err == nil && (!delivered || pc.alt != nil) {
        //绑定wantConn失败
        //放到存放空闲连接idleConn的map中
		t.putOrCloseIdleConn(pc)
	}
	if err != nil {
		t.decConnsPerHost(w.key)
	}
}

func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *persistConn, err error) {
	pconn = &persistConn{
		t:             t,
		cacheKey:      cm.key(),
		reqch:         make(chan requestAndChan, 1),
		writech:       make(chan writeRequest, 1),
		closech:       make(chan struct{}),
		writeErrCh:    make(chan error, 1),
		writeLoopDone: make(chan struct{}),
	}
    ...
    // 创建 tcp 连接，给pconn.conn
	conn, err := t.dial(ctx, "tcp", cm.addr())
	if err != nil {
		return nil, wrapErr(err)
	}
	pconn.conn = conn
    ...
    //开启两个goroutine处理读写
    go pconn.readLoop()
	go pconn.writeLoop()
	return pconn, nil
}

func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err error) {
	...
	// 请求数据写入到 writech channel中
	pc.writech <- writeRequest{req, writeErrCh, continueCh}

	// 接收响应的channel
	resc := make(chan responseAndError)
	// 接收响应的结构体 requestAndChan 写到 reqch channel中
	pc.reqch <- requestAndChan{
		req:        req.Request,
		cancelKey:  req.cancelKey,
		ch:         resc,
		...
	}
	...
	for {
        ...
        select { 
    		// 接收到响应数据
		case re := <-resc:
			...
			// return响应数据
			return re.res, nil
		...
	}
}