1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
type Transport struct {
    //操作空闲连接需要获取锁
    idleMu       sync.Mutex
    //空闲连接池，key为协议目标地址等组合
    idleConn     map[connectMethodKey][]*persistConn // most recently used at end
    //等待空闲连接的队列，基于切片实现，队列大小无限制
    idleConnWait map[connectMethodKey]wantConnQueue  // waiting getConns
    
    //排队等待建立连接需要获取锁
    connsPerHostMu   sync.Mutex
    //每个host建立的连接数
    connsPerHost     map[connectMethodKey]int
    //等待建立连接的队列，同样基于切片实现，队列大小无限制
    connsPerHostWait map[connectMethodKey]wantConnQueue // waiting getConns
    
    //tls client用于tls协商的配置
    TLSClientConfig *tls.Config
    //tls协商的超时时间
    TLSHandshakeTimeout time.Duration                       

    //是否取消长连接，默认使用长连接
    DisableKeepAlives bool
    //是否取消HTTP压缩
    DisableCompression bool
    
    //所有host的连接池最大连接数量，默认无穷大
    MaxIdleConns int
    //每个目标host最大空闲连接数；默认为2（注意默认值）
    MaxIdleConnsPerHost int
    //对每个host可建立的最大连接数量，0表示不限制
    MaxConnsPerHost int
    //连接多少时间没有使用则被关闭
    IdleConnTimeout time.Duration
    //发送完request后等待serve response的时间
    ResponseHeaderTimeout time.Duration
    //限制客户端在发送一个包含：100-continue的http报文头后，等待收到一个go-ahead响应报文所用的时间。
    ExpectContinueTimeout time.Duration
    //在tls协商带NPN/ALPN的扩展后，transport如何切换到其他协议。指tls之上的协议(next指的就是tls之上的意思)
    TLSNextProto map[string]func(authority string, c *tls.Conn) RoundTripper 
    //在CONNECT请求时，配置request的首部信息，可选
    ProxyConnectHeader Header       
    //指定server响应首部的最大字节数
    MaxResponseHeaderBytes int64
    //写bufffer的大小，默认为4096。             
    WriteBufferSize int
    //读bufffer的大小，默认为4096。
	ReadBufferSize int
	//是否启用HTTP/2，默认为启用
	ForceAttemptHTTP2 bool
}

1
2
3
4
func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {}

func (t *Transport) tryPutIdleConn(pconn *persistConn) error {}

1
2
3
4
5
6
7
8
//getConn方法内部实现

if delivered := t.queueForIdleConn(w); delivered {
    return pc, nil
}
    
t.queueForDial(w)

1
2
3
4
5
6
7
8
9
10
11
12
select {
    case <-w.ready:
        return w.pc, w.err
        
    //超时被取消
    case <-req.Cancel:
        return nil, errRequestCanceledConn
    ……
}

var errRequestCanceledConn = errors.New("net/http: request canceled while waiting for connection") // TODO: unify?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
func (t *Transport) queueForIdleConn(w *wantConn) (delivered bool) {
    //如果配置了空闲超时时间，获取到连接需要检测，超时则关闭连接
    if t.IdleConnTimeout > 0 {
        oldTime = time.Now().Add(-t.IdleConnTimeout)
    }
    
    if list, ok := t.idleConn[w.key]; ok {
        for len(list) > 0 && !stop {
            pconn := list[len(list)-1]
            tooOld := !oldTime.IsZero() && pconn.idleAt.Round(0).Before(oldTime)
            //超时了，关闭连接
            if tooOld {
                go pconn.closeConnIfStillIdle()
            }
            
            //分发连接到wantConn
            delivered = w.tryDeliver(pconn, nil)
        }
    }
    
    //排队等待空闲连接
    q := t.idleConnWait[w.key]
    q.pushBack(w)
    t.idleConnWait[w.key] = q
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func (t *Transport) queueForDial(w *wantConn) {
    //如果没有限制最大连接数，直接建立连接
    if t.MaxConnsPerHost <= 0 {
        go t.dialConnFor(w)
        return
    }
    
    //如果没超过连接数限制，直接建立连接
    if n := t.connsPerHost[w.key]; n < t.MaxConnsPerHost {
        go t.dialConnFor(w)
        return
    }
    
    //排队等待连接建立
    q := t.connsPerHostWait[w.key]
    q.pushBack(w)
    t.connsPerHostWait[w.key] = q
}

1
2
3
4
5
func (w *wantConn) tryDeliver(pc *persistConn, err error) bool {
    w.pc = pc
    close(w.ready)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func (t *Transport) tryPutIdleConn(pconn *persistConn) error {
    //禁用长连接；或者最大空闲连接数不合法
    if t.DisableKeepAlives || t.MaxIdleConnsPerHost < 0 {
        return errKeepAlivesDisabled
    }
    
    if q, ok := t.idleConnWait[key]; ok {
        //如果等待队列不为空，分发连接
        for q.len() > 0 {
            w := q.popFront()
            if w.tryDeliver(pconn, nil) {
                done = true
                break
            }
        }
    }
    
    //空闲连接数目超过限制，默认为DefaultMaxIdleConnsPerHost=2
    idles := t.idleConn[key]
    if len(idles) >= t.maxIdleConnsPerHost() {
        return errTooManyIdleHost
    }

}

1
2
pconn.idleTimer = time.AfterFunc(t.IdleConnTimeout, pconn.closeConnIfStillIdle)

1
2
3
4
5
6
7
8
9
10
queue    []*wantConn

//入队
queue = append(queue, w)

//出队
v := queue[0]
queue[0] = nil
queue = queue[1:]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func (q *wantConnQueue) pushBack(w *wantConn) {
    q.tail = append(q.tail, w)
}

func (q *wantConnQueue) popFront() *wantConn {
    if q.headPos >= len(q.head) {
        if len(q.tail) == 0 {
            return nil
        }
        // Pick up tail as new head, clear tail.
        q.head, q.headPos, q.tail = q.tail, 0, q.head[:0]
    }
    w := q.head[q.headPos]
    q.head[q.headPos] = nil
    q.headPos++
    return w
}

1
2
3
4
5
6
7
8
9
10
11
12
13
resp, err := http.Get("http://www.baidu.com")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

body, err := ioutil.ReadAll(resp.Body)
if err != nil {
	fmt.Println("read body err:", err)
}

fmt.Println("body:", string(body))

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

1
2
3
// DefaultClient is the default Client and is used by Get, Head, and Post.
var DefaultClient = &Client{}

1
2
3
4
client := http.Client{
 Timeout: 10 * time.Second,
}

1
2
3
4
5
6
type Client struct {
	url    string
	client *http.Client
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// NewClient 初始化客户端
func NewClient(url string) *Client {
	return &Client{
		url: url,
		client: &http.Client{
			Transport: &http.Transport{
				MaxIdleConnsPerHost: 10, // 每台主机保持的最大空闲连接
				MaxConnsPerHost:     10, // 限制每个主机的连接总数
				TLSClientConfig:     &tls.Config{InsecureSkipVerify: true},
			},
		},
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// DefaultTransport is the default implementation of Transport and is
// used by DefaultClient. It establishes network connections as needed
// and caches them for reuse by subsequent calls. It uses HTTP proxies
// as directed by the $HTTP_PROXY and $NO_PROXY (or $http_proxy and
// $no_proxy) environment variables.
var DefaultTransport RoundTripper = &Transport{
	Proxy: ProxyFromEnvironment,
	DialContext: (&net.Dialer{
		Timeout:   30 * time.Second,
		KeepAlive: 30 * time.Second,
	}).DialContext,
	ForceAttemptHTTP2:     true,
	MaxIdleConns:          100,
	IdleConnTimeout:       90 * time.Second,
	TLSHandshakeTimeout:   10 * time.Second,
	ExpectContinueTimeout: 1 * time.Second,
}

// DefaultMaxIdleConnsPerHost is the default value of Transport's
// MaxIdleConnsPerHost.
const DefaultMaxIdleConnsPerHost = 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// Client
type Client struct {
	url    string
	client *http.Client
}

// NewClient 初始化客户端
func NewClient(url string) *Client {
	return &Client{
		url: url,
		client: &http.Client{
			Transport: &http.Transport{
				DialContext: (&net.Dialer{
					Timeout:   30 * time.Millisecond,  //限制建立TCP连接的时间
					KeepAlive: 10 * time.Millisecond,  //指定 TCP keep-alive 探测发送到对等方的频率。
				}).DialContext,
				ForceAttemptHTTP2:     true,  //是否启用HTTP/2
				IdleConnTimeout:       90 * time.Millisecond, //连接多少时间没有使用则被关闭
				TLSHandshakeTimeout:   10 * time.Second, //tls协商的超时时间
				ExpectContinueTimeout: 1 * time.Second, //等待收到一个go-ahead响应报文所用的时间
				MaxIdleConns:          100,  //最大空闲连接数
				MaxIdleConnsPerHost: 10, // 每台主机保持的最大空闲连接
				MaxConnsPerHost:     10, // 限制每个主机的连接总数
				TLSClientConfig:     &tls.Config{InsecureSkipVerify: true},
			},
			Timeout: 20 * time.Second, //从发起连接到接收响应报文结束
		},
	}
}

// httpRequest http请求
func (c *Client) HttpRequest(methed, params string) (resBody []byte, err error) {
	// 初始化请求
	body := strings.NewReader(params)
	fmt.Println(body)
	req, _ := http.NewRequest("POST", c.url+methed, body)
	fmt.Println("req===============",req)

	if err != nil {
		return nil, errors.Wrap(err, "Http NewRequest")
	}
	// 执行请求
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Accept", "application/json")
	res, err := c.client.Do(req)
	if err != nil {
		return nil, errors.Wrap(err, "Client Do")
	}
	defer res.Body.Close()
	// 接收返回结果
	resBody, err = ioutil.ReadAll(res.Body)
	fmt.Println(string(resBody))
	if err != nil {
		return nil, errors.Wrap(err, "ioutil.ReadAll")
	}
	return resBody, nil
}

// httpRequest http请求
func (c *Client) HttpGetRequest(methed, params string) (resBody []byte, err error) {

	// 初始化请求
	req, err := http.NewRequest("GET", c.url+methed+params, nil)
	if err != nil {
		return nil, errors.Wrap(err, "Http NewRequest")
	}

	// 执行请求
	req.Header.Add("Content-Type", "application/json")
	res, err := c.client.Do(req)
	if err != nil {
		return nil, errors.Wrap(err, "Client Do")
	}
	defer res.Body.Close()

	// 接收返回结果
	resBody, err = ioutil.ReadAll(res.Body)
	if err != nil {
		return nil, errors.Wrap(err, "ioutil.ReadAll")
	}
	return resBody, nil
}

1
2
Timeout: 10 * time.Second, //从发起连接到接收响应报文结束

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 初始化请求
req, err := http.NewRequest("GET", c.url+methed+params, nil)
if err != nil {
	return nil, errors.Wrap(err, "Http NewRequest")
}
req.Header.Add("Content-Type", "application/json")
	
// 执行请求
res, err := c.client.Do(req)
	if err != nil {
		return nil, errors.Wrap(err, "Client Do")
	}

// 关闭请求
defer res.Body.Close()

1
2
func (c *Client) Do(req *Request) (resp *Response, err error)

1
2
*Request 可以通过这个参数来自定义 Request

1
2
3
*Response 如果获取到了数据，会将数据保存在 Response 中
error 如果请求数据的时候出现错误，会返回一个 error ，并将具体的错误记录到 error 中

1
2
httpReq.Close = true

1
2
3
4
5
6
7
8
9
10
11
httpReq, err := http.NewRequest("POST", url, bodyReader)
if err != nil {
	return nil, exception.Build("http NewRequest error", err)
}

httpReq.Close = true
httpReq.Header.Set("Content-Type", "application/json")

client := httpClient()
resp, err := client.Do(httpReq)

1
2
3
4
5
6
7
8
9
// 短连接池
func httpClient() http.Client {
	return http.Client{
		Transport: &http.Transport{
			DisableKeepAlives: true,
		},
	}
}