Golang http之client源码详解

转自 Golang http之server源码详解-蒲公英云

仅做个人备份

http客户端介绍

1. http 是典型的 C/S 架构，客户端向服务端发送请求（request），服务端做出应答（response）。本文章主要介绍Golang中http客户端的相关源码，源码主要在net/http/client.go中。源码版本号为1.10.3

一个简单的http 客户端请求例子：

1. package main
2. import (
3. "log"
4. "fmt"
5. "net/http"
6. "io/ioutil"
7. )
9. func main() {
10. resp,err := http.Get("http://www.baidu.com")
11. if err != nil {
12. log.Fatal(err)
13. }
15. d,err := ioutil.ReadAll(resp.Body)
16. if err != nil {
17. log.Fatal(err)
18. }
19. resp.Body.Close()
21. fmt.Println(string(d))
22. }
24. http客户端直接调用http包的Get获取相关请求数据。如果客户端在请求时需要设置header，则需要使用NewRequest和 DefaultClient.Do。我们看一下设置Header的操作例子
26. package main
28. import (
29. "fmt"
30. "net/http"
31. "log"
32. "io/ioutil"
33. )
35. func main() {
36. req,err := http.NewRequest("GET","http://www.baidu.com",nil)
37. if err != nil {
38. log.Fatal(err)
39. }
40. req.Header.Set("key","value")
41. resp ,err := http.DefaultClient.Do(req)
42. if err != nil {
43. log.Fatal(err)
44. }
46. byts,err := ioutil.ReadAll(resp.Body)
47. defer resp.Body.Close()
48. if err != nil {
49. log.Fatal(err)
50. }
51. fmt.Println(string(byts))
52. }

源码分析

1. **Client结构体**
3. type Client struct {
5. Transport RoundTripper
7. CheckRedirect func(req *Request, via []*Request) error
10. Jar CookieJar
13. Timeout time.Duration
14. }

我们看到Client的结构体非常简单，只有几个字段。Client表示一个HTTP客户端，它的默认值是DefaultClient会默认使用DefaultTransport的可用客户端。

Transport表示HTTP事务，用于处理客户端的请求并等待服务端的响应

CheckRedirect 用于指定处理重定向的策略

Jar指定cookie的jar

Timeout 指定客户端请求的最大超时时间，该超时时间包括连接,任何的重定向以及读取响

应体的时间。如果服务器已经返回响应信息该计时器仍然运行，并将终端Response.Body的读取。如果Timeout为0则意味着没有超时

RoundTripper接口

1. type RoundTripper interface {
2. RoundTrip(*Request) (*Response, error)
3. }

RoundTripper表示执行单个HTTP事务的接口，必须是并发安全的。它的相关源码我们在前面已经介绍过了，可以参考以下地址

https://blog.csdn.net/skh2015java/article/details/89340215

我们通过一些常用的http包对外提供的方法来窥探http客户端的请求流程和机制。

Get方法

1. func Get(url string) (resp *Response, err error) {
3. return DefaultClient.Get(url)
5. }
7. var DefaultClient = &Client{}

Get方法使用的是http包对外提供的默认客户端DefaultClient

DefaultClient的Get方法如下

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

看到首先创建了Request结构体req,指定了请求的Method和url。

1. func (c *Client) Do(req *Request) (*Response, error) {
2. //如果请求的URL为nil，则关闭请求体，并且返回error
3. if req.URL == nil {
4. req.closeBody()
5. return nil, errors.New("http: nil Request.URL")
6. }
8. var (
9. deadline = c.deadline()
10. reqs []*Request
11. resp *Response
12. copyHeaders = c.makeHeadersCopier(req) //拷贝一份headers
13. reqBodyClosed = false // have we closed the current req.Body?
15. // Redirect behavior:
16. redirectMethod string
17. includeBody bool
18. )
19. //错误处理函数
20. uerr := func(err error) error {
21. // the body may have been closed already by c.send()
22. if !reqBodyClosed {
23. req.closeBody()
24. }
25. method := valueOrDefault(reqs[0].Method, "GET")
26. var urlStr string
27. if resp != nil && resp.Request != nil {
28. urlStr = resp.Request.URL.String()
29. } else {
30. urlStr = req.URL.String()
31. }
32. return &url.Error{
33. Op: method[:1] + strings.ToLower(method[1:]),
34. URL: urlStr,
35. Err: err,
36. }
37. }
39. for {
40. // For all but the first request, create the next
41. // request hop and replace req.
42. /*
43. 对于非第一个请求 ，创建下一个hop并且替换req
44. */
45. if len(reqs) > 0 { //有重定向的情况
46. loc := resp.Header.Get("Location") //获取响应resp的Header中的Location对应的值
47. if loc == "" {
48. resp.closeBody()
49. return nil, uerr(fmt.Errorf("%d response missing Location header", resp.StatusCode))
50. }
51. u, err := req.URL.Parse(loc) //将loc解析成URL
52. if err != nil {
53. resp.closeBody()
54. return nil, uerr(fmt.Errorf("failed to parse Location header %q: %v", loc, err))
55. }
56. host := ""
57. if req.Host != "" && req.Host != req.URL.Host { //解析host
58. // If the caller specified a custom Host header and the
59. // redirect location is relative, preserve the Host header
60. // through the redirect. See issue #22233.
61. if u, _ := url.Parse(loc); u != nil && !u.IsAbs() {
62. host = req.Host
63. }
64. }
65. ireq := reqs[0]
66. //获取重定向的Request req
67. req = &Request{
68. Method: redirectMethod,
69. Response: resp,
70. URL: u,
71. Header: make(Header),
72. Host: host,
73. Cancel: ireq.Cancel,
74. ctx: ireq.ctx,
75. }
76. if includeBody && ireq.GetBody != nil {
77. req.Body, err = ireq.GetBody()
78. if err != nil {
79. resp.closeBody()
80. return nil, uerr(err)
81. }
82. req.ContentLength = ireq.ContentLength
83. }
85. // Copy original headers before setting the Referer,
86. // in case the user set Referer on their first request.
87. // If they really want to override, they can do it in
88. // their CheckRedirect func.
89. copyHeaders(req)
91. // Add the Referer header from the most recent
92. // request URL to the new one, if it's not https->http:
93. /*
94. 如果不是https-> http，请将最新请求URL中的Referer标头添加到新标头中：
95. */
96. if ref := refererForURL(reqs[len(reqs)-1].URL, req.URL); ref != "" {
97. req.Header.Set("Referer", ref)
98. }
99. err = c.checkRedirect(req, reqs)
101. // Sentinel error to let users select the
102. // previous response, without closing its
103. // body. See Issue 10069.
104. if err == ErrUseLastResponse {
105. return resp, nil
106. }
108. // Close the previous response's body. But
109. // read at least some of the body so if it's
110. // small the underlying TCP connection will be
111. // re-used. No need to check for errors: if it
112. // fails, the Transport won't reuse it anyway.
113. const maxBodySlurpSize = 2 << 10
114. if resp.ContentLength == -1 || resp.ContentLength <= maxBodySlurpSize {
115. io.CopyN(ioutil.Discard, resp.Body, maxBodySlurpSize)
116. }
117. resp.Body.Close()
119. if err != nil {
120. // Special case for Go 1 compatibility: return both the response
121. // and an error if the CheckRedirect function failed.
122. // See https://golang.org/issue/3795
123. // The resp.Body has already been closed.
124. ue := uerr(err)
125. ue.(*url.Error).URL = loc
126. return resp, ue
127. }
128. }
130. reqs = append(reqs, req) //将req写入到reps中
131. var err error
132. var didTimeout func() bool
133. //发送请求到服务端，并获取响应信息resp
134. if resp, didTimeout, err = c.send(req, deadline); err != nil {
135. // c.send() always closes req.Body
136. reqBodyClosed = true
137. if !deadline.IsZero() && didTimeout() { //已超时
138. err = &httpError{
139. err: err.Error() + " (Client.Timeout exceeded while awaiting headers)",
140. timeout: true,
141. }
142. }
143. return nil, uerr(err)
144. }
146. var shouldRedirect bool
147. //根据请求的Method，响应的消息resp和 第一次请求req获取是否需要重定向，重定向的方法，重定向时是否包含body
148. redirectMethod, shouldRedirect, includeBody = redirectBehavior(req.Method, resp, reqs[0])
149. if !shouldRedirect { //不用重发，则返回
150. return resp, nil
151. }
153. req.closeBody()
154. }
155. }

Do发送一个HTTP请求并且返回一个客户端响应，遵循客户端上配置的策略（例如redirects，cookie，auth）,如果服务端回复的Body非空，则该Body需要客户端关闭，否则会对”keep-alive”请求中的持久化TCP连接可能不会被复用。

如果服务端回复一个重定向，客户端首先会调用CheckRedirect函数来确定是否遵循重定向。

如果允许，一个301,302或者303重定向会导致后续请求使用HTTP的GET方法。

该方法的大致流程如下：

1.首先会进行相关参数的校验

2.参数校验通过后，会调用send方法来发送客户端请求，并获取服务端的响应信息。

3.如果服务端回复的不需要重定向，则将该响应resp返回

4.如果服务端回复的需要重定向，则获取重定向的Request，并进行重定向校验

5.重定向校验通过后，会继续调用send方法来发送重定向的请求。

6.不需要重定向时返回从服务端响应的结果resp。

send方法

1. func (c *Client) send(req *Request, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
2. //如果Jar不为nil，则将Jar中的Cookie添加到请求中
3. if c.Jar != nil {
4. for _, cookie := range c.Jar.Cookies(req.URL) {
5. req.AddCookie(cookie)
6. }
7. }
8. //发送请求到服务端，并返回从服务端读取到的response信息resp
9. resp, didTimeout, err = send(req, c.transport(), deadline)
10. if err != nil {
11. return nil, didTimeout, err
12. }
13. if c.Jar != nil {
14. if rc := resp.Cookies(); len(rc) > 0 {
15. c.Jar.SetCookies(req.URL, rc)
16. }
17. }
18. return resp, nil, nil
19. }
21. send方法主要调用send函数将请求发送到Transport中，并返回response。
23. 如果Jar不为nil，则将Jar中的Cookie添加到请求中，并调用send函数将请求发送到服务端，并返回从服务端读取到的response信息resp。需要注意的是如果用户自定义了Transport则用用户自定义的，如果没有则用默认的DefaultTransport。

send函数

1. func send(ireq *Request, rt RoundTripper, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
2. req := ireq // req is either the original request, or a modified fork req是原始的请求或者一个拷贝
4. /*
5. 条件判断：
6. 如果RoundTripper为nil 或者请求的URL为nil 或者 请求的RequestURI为空，则关闭请求体，返回error
7. */
8. .......
10. // forkReq forks req into a shallow clone of ireq the first
11. // time it's called.
12. /*
13. 第一次调用时，将req转换为ireq的拷贝
14. */
15. forkReq := func() {
16. if ireq == req {
17. req = new(Request)
18. *req = *ireq // shallow clone
19. }
20. }
22. // Most the callers of send (Get, Post, et al) don't need
23. // Headers, leaving it uninitialized. We guarantee to the
24. // Transport that this has been initialized, though.
25. /*
26. 由于大多数的调用(Get,Post等)都不需要Headers，而是将其保留成为初始化状态。不过我们传输到Transport需要保证其被初始化，所以这里将
27. 没有Header为nil的进行初始化
28. 如果请求头为nil
29. */
30. if req.Header == nil {
31. forkReq()
32. req.Header = make(Header)
33. }
35. /*
36. 如果URL中协议用户和密码信息，并且请求头的Authorization为空，我们需要设置Header的Authorization
37. */
38. if u := req.URL.User; u != nil && req.Header.Get("Authorization") == "" {
39. username := u.Username()
40. password, _ := u.Password()
41. forkReq()
42. req.Header = cloneHeader(ireq.Header)
43. req.Header.Set("Authorization", "Basic "+basicAuth(username, password))
44. }
46. //如果设置了超时时间，则需要调用forkReq，来确保req是ireq的拷贝，而不是执行同一地址的指针
47. if !deadline.IsZero() {
48. forkReq()
49. }
51. //根据deadline设置超时
52. stopTimer, didTimeout := setRequestCancel(req, rt, deadline)
54. //调用RoundTrip完成一个HTTP事务，并返回一个resp
55. resp, err = rt.RoundTrip(req)
56. if err != nil { //如果err不为nil
57. stopTimer() //取消监听超时
58. if resp != nil {
59. log.Printf("RoundTripper returned a response & error; ignoring response")
60. }
61. if tlsErr, ok := err.(tls.RecordHeaderError); ok {
62. // If we get a bad TLS record header, check to see if the
63. // response looks like HTTP and give a more helpful error.
64. // See golang.org/issue/11111.
65. if string(tlsErr.RecordHeader[:]) == "HTTP/" {
66. err = errors.New("http: server gave HTTP response to HTTPS client")
67. }
68. }
69. return nil, didTimeout, err
70. }
71. if !deadline.IsZero() { //如果设置了超时，则将Body转成cancelTimerBody
72. resp.Body = &cancelTimerBody{
73. stop: stopTimer,
74. rc: resp.Body,
75. reqDidTimeout: didTimeout,
76. }
77. }
78. return resp, nil, nil
79. }

该函数的主要作用是调用RoundTrip完成一个HTTP事务，并返回一个resp。

Post和PostForm方法

1. func Post(url string, contentType string, body io.Reader) (resp *Response, err error) {
2. return DefaultClient.Post(url, contentType, body)
3. }
5. func (c *Client) Post(url string, contentType string, body io.Reader) (resp *Response, err error) {
6. req, err := NewRequest("POST", url, body)
7. if err != nil {
8. return nil, err
9. }
10. req.Header.Set("Content-Type", contentType)
11. return c.Do(req)
12. }
15. func PostForm(url string, data url.Values) (resp *Response, err error) {
16. return DefaultClient.PostForm(url, data)
17. }
19. func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error) {
20. return c.Post(url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
21. }

看到Post和PostForm最终都是调用默认客户端DefaultClient的Post方法，然后调用Do来处理请求并获得相应信息。

#

Request结构体和如何设置Header

1. type Request struct {
3. //HTTP的方法(GET、POST、PUT等)
4. Method string
7. /*
8. 请求解析后的url
9. */
10. URL *url.URL
12. Proto string // "HTTP/1.0" 协议版本
13. ProtoMajor int // 1 主版本号
14. ProtoMinor int // 0 次版本号
16. //请求到服务器携带的请求头信息,用map存储
17. Header Header
20. //请求的消息体,HTTP客户端的Transport负责调用Close方法关闭
21. Body io.ReadCloser
24. /*
25. GetBody 定义一个可选的方法用来返回Body的副本
26. 当客户端的请求被多次重定向的时候，会用到该函数
27. */
28. GetBody func() (io.ReadCloser, error)
31. /*
32. ContentLength 存储消息体的字节长度
33. 如果为 -1 则表示消息长度未知
34. */
35. ContentLength int64
38. /*
39. TransferEncoding列出从最外层到最内层的传输编码。
40. 空列表表示“identity”编码。 TransferEncoding通常可以忽略; 发送和接收请求时，会根据需要自动添加和删除分块编码。
41. */
42. TransferEncoding []string
45. /*
46. Close对于服务端是 回复此请求后是否关闭连接
47. 对于客户端发送此请求并读取服务端的响应后是否关闭连接
48. 对于服务器请求，HTTP服务器自动处理此请求，处理程序不需要此字段。
49. 对于客户端请求，设置此字段可防止在对相同主机的请求之间重复使用TCP连接，就像设置了Transport.DisableKeepAlives一样。
50. */
51. Close bool
53. /*
54. 主机地址
55. 对于服务器请求，Host指定要在其上查找URL的主机
56. 对于客户端请求，Host可以选择覆盖要发送的Host头。 如果为空，则Request.Write方法使用URL.Host的值。 主机可能包含国际域名。
57. */
58. Host string
61. /*
62. 储存解析后的表单数据，包括URL字段查询的参数和 POST或PUT表单数据
63. 该字段仅在调用ParseForm后可用。 HTTP客户端忽略Form并使用Body。
64. */
65. Form url.Values
68. /*
69. PostForm储存了 从POST,PATCH,PUT解析后表单数据
70. 该字段仅在调用ParseForm后可用，HTTP客户端会忽略PostForm而是使用Body
71. */
72. PostForm url.Values
75. /*
76. MultipartForm是解析的多部分表单，包括文件上载。 该字段仅在调用ParseMultipartForm后可用。
77. HTTP客户端忽略MultipartForm而使用Body
78. */
79. MultipartForm *multipart.Form
83. /*
84. 指定请求体发送之后发送的额外请求头
85. */
86. Trailer Header
89. /*
90. RemoteAddr允许HTTP服务器和其他软件记录发送请求的网络地址，通常用于记录。 ReadRequest未填写此字段，并且没有已定义的格式。
91. 在调用处理程序之前，此程序包中的HTTP服务器将RemoteAddr设置为“IP：port”地址。 HTTP客户端忽略此字段。
92. */
93. RemoteAddr string
96. /*
97. RequestURI是客户端发送到服务端的未经解析的Request-URI
98. */
99. RequestURI string
102. /*
104. TLS允许HTTP服务器和其他软件记录有关收到请求的TLS连接的信息。 ReadRequest未填写此字段。
105. 此包中的HTTP服务器在调用处理程序之前为启用TLS的连接设置字段; 否则它会离开现场零。 HTTP客户端忽略此字段。
106. */
107. TLS *tls.ConnectionState
110. /*
111. 用于通知客户端的请求应该被取消.不是所有的RoundTripper都支持取消
112. 此字段不使用服务端的请求
113. */
114. Cancel <-chan struct{}
117. /*
118. 重定向时使用该字段
119. */
120. Response *Response
122. /*
123. 客户端或者服务端的上下文。只有通过WithContext来改变该上下文
124. */
125. ctx context.Context //请求的上下文
126. }

Request表示一个HTTP的请求，用于客户端发送，服务端接收。

Method表示HTTP的方法(常用的如：GET、POST、PUT、DELETE等)

Header请求到服务器时携带的请求头信息，用map存储。

Header的格式如下：

type Header map[string][]string

Header用 key-value键值对 表示HTTP header

操作Header的常用方法如下：

1. //添加value到指定key，如果value已存在，则追加，因为value是[]string的格式。即一个// key可以对应多个value
2. func (h Header) Add(key, value string) {
3. textproto.MIMEHeader(h).Add(key, value)
4. }
6. //设置key的value，value会替换key对应的已存在的value
7. func (h Header) Set(key, value string) {
8. textproto.MIMEHeader(h).Set(key, value)
9. }
11. //获取与key关联的第一个value值，如果没有则返回""(空字符串),
12. func (h Header) Get(key string) string {
13. return textproto.MIMEHeader(h).Get(key)
14. }
17. //删除Header中指定的key
18. func (h Header) Del(key string) {
19. textproto.MIMEHeader(h).Del(key)
20. }

以上就是http客户端请求的大致流程及相关方法和结构体的介绍，如有问题还请指正