Golang获取有重定向信息的response的location

maxtiger

在用golang做模拟登录某个网站的功能时发现了一个问题：如何获取该网站带有重定向信息的Response?或者说我只需要
这个Response中的location信息即可，但是发现对于go的标准库net/http来说如果不hack这个库是没办法直接获取带有重
定向信息的Response，而且目前大多第三方的http库也是基于标准库net/http的，貌似就要改net/http库或库本身就提供了
对于重定向的设置？

那么我们就得先查看一下net/http库的源码了，通常我们都会用http.Client的Do方法发起一个请求，首先看一下它的源码：

1. // Do sends an HTTP request and returns an HTTP response, following
   
2. // policy (e.g. redirects, cookies, auth) as configured on the client.
   
3. //
   
4. // An error is returned if caused by client policy (such as
   
5. // CheckRedirect), or if there was an HTTP protocol error.
   
6. // A non-2xx response doesn't cause an error.
   
7. //
   
8. // When err is nil, resp always contains a non-nil resp.Body.
   
9. //
   
10. // Callers should close resp.Body when done reading from it. If
    
11. // resp.Body is not closed, the Client's underlying RoundTripper
    
12. // (typically Transport) may not be able to re-use a persistent TCP
    
13. // connection to the server for a subsequent "keep-alive" request.
    
14. //
    
15. // The request Body, if non-nil, will be closed by the underlying
    
16. // Transport, even on errors.
    
17. //
    
18. // Generally Get, Post, or PostForm will be used instead of Do.
    
19. func (c *Client) Do(req *Request) (resp *Response, err error) {
    
20.     if req.Method == "GET" || req.Method == "HEAD" {
    
21.         return c.doFollowingRedirects(req, shouldRedirectGet)
    
22.     }
    
23.     if req.Method == "POST" || req.Method == "PUT" {
    
24.         return c.doFollowingRedirects(req, shouldRedirectPost)
    
25.     }
    
26.     return c.send(req)
    
27. }

复制代码

由源码的上方的注释可发现Do方法是不会返回有重定向信息的Response的，只会返回已经重定向跳转成功后的Response，而且会根据是否CheckRedirect返回error云云
那么假设我们要发起的是一个Get请求，所以进入c.doFollowingRedirects()方法中去看看

1. func (c *Client) doFollowingRedirects(ireq *Request, shouldRedirect func(int) bool) (resp *Response, err error) {
   
2.     var base *url.URL
   
3.     redirectChecker := c.CheckRedirect
   
4.     if redirectChecker == nil {
   
5.         redirectChecker = defaultCheckRedirect
   
6.     }
   
7.     var via []*Request
   
8. 
   
9.     if ireq.URL == nil {
   
10.         ireq.closeBody()
    
11.         return nil, errors.New("http: nil Request.URL")
    
12.     }
    
13. 
    
14.     var reqmu sync.Mutex // guards req
    
15.     req := ireq
    
16. 
    
17.     var timer *time.Timer
    
18.     if c.Timeout > 0 {
    
19.         type canceler interface {
    
20.             CancelRequest(*Request)
    
21.         }
    
22.         tr, ok := c.transport().(canceler)
    
23.         if !ok {
    
24.             return nil, fmt.Errorf("net/http: Client Transport of type %T doesn't support CancelRequest; Timeout not supported", c.transport())
    
25.         }
    
26.         timer = time.AfterFunc(c.Timeout, func() {
    
27.             reqmu.Lock()
    
28.             defer reqmu.Unlock()
    
29.             tr.CancelRequest(req)
    
30.         })
    
31.     }
    
32. 
    
33.     urlStr := "" // next relative or absolute URL to fetch (after first request)
    
34.     redirectFailed := false
    
35.     for redirect := 0; ; redirect++ {
    
36.         if redirect != 0 {
    
37.             nreq := new(Request)
    
38.             nreq.Method = ireq.Method
    
39.             if ireq.Method == "POST" || ireq.Method == "PUT" {
    
40.                 nreq.Method = "GET"
    
41.             }
    
42.             nreq.Header = make(Header)
    
43.             nreq.URL, err = base.Parse(urlStr)
    
44.             if err != nil {
    
45.                 break
    
46.             }
    
47.             if len(via) > 0 {
    
48.                 // Add the Referer header.
    
49.                 lastReq := via[len(via)-1]
    
50.                 if ref := refererForURL(lastReq.URL, nreq.URL); ref != "" {
    
51.                     nreq.Header.Set("Referer", ref)
    
52.                 }
    
53. 
    
54.                 err = redirectChecker(nreq, via)
    
55.                 if err != nil {
    
56.                     redirectFailed = true
    
57.                     break
    
58.                 }
    
59.             }
    
60.             reqmu.Lock()
    
61.             req = nreq
    
62.             reqmu.Unlock()
    
63.         }
    
64. 
    
65.         urlStr = req.URL.String()
    
66.         if resp, err = c.send(req); err != nil {
    
67.             break
    
68.         }
    
69. 
    
70. 
    
71.         if shouldRedirect(resp.StatusCode) {
    
72. 
    
73.             // Read the body if small so underlying TCP connection will be re-used.
    
74.             // No need to check for errors: if it fails, Transport won't reuse it anyway.
    
75.             const maxBodySlurpSize = 2 << 10
    
76.             if resp.ContentLength == -1 || resp.ContentLength <= maxBodySlurpSize {
    
77.                 io.CopyN(ioutil.Discard, resp.Body, maxBodySlurpSize)
    
78.             }
    
79.             resp.Body.Close()
    
80.             if urlStr = resp.Header.Get("Location"); urlStr == "" {
    
81.                 err = errors.New(fmt.Sprintf("%d response missing Location header", resp.StatusCode))
    
82.                 break
    
83.             }
    
84. 
    
85.             base = req.URL
    
86.             via = append(via, req)
    
87.             continue
    
88.         }
    
89.         if timer != nil {
    
90.             resp.Body = &cancelTimerBody{timer, resp.Body}
    
91.         }
    
92.         return resp, nil
    
93.     }
    
94. 
    
95.     method := ireq.Method
    
96.     urlErr := &url .Error{
    
97.         Op:  method[0:1] + strings.ToLower(method[1:]),
    
98.         URL: urlStr,
    
99.         Err: err,
    
100.     }
     
101. 
     
102.     if redirectFailed {
     
103.         // Special case for Go 1 compatibility: return both the response
     
104.         // and an error if the CheckRedirect function failed.
     
105.         // See http://golang.org/issue/3795
     
106.         return resp, urlErr
     
107.     }
     
108. 
     
109.     if resp != nil {
     
110.         resp.Body.Close()
     
111.     }
     
112.     return nil, urlErr
     
113. }

复制代码

在上述代码中发现了有检查是否进行重定向的代码：

1. redirectChecker := c.CheckRedirect
   
2.     if redirectChecker == nil {
   
3.         redirectChecker = defaultCheckRedirect
   
4.     }

复制代码

redirectChecker是一个这样的函数：func(req Request, via []Request) error
发现了可在client中设置自己的redirectChecker，就是只要实现了func(req Request, via []Request) error即可，其功能是由源码的
defaultCheckRedirect可知是控制重定向跳转的次数而已。

1. func defaultCheckRedirect(req *Request, via []*Request) error {
   
2.     if len(via) >= 10 {
   
3.         return errors.New("stopped after 10 redirects")
   
4.     }
   
5.     return nil
   
6. }

复制代码

defaultCheckRedirect中规定重定向跳转不能超过10次，否则返回error，那么如果我们要禁止跳转重定向的话自己实现一个
CheckRedirect，把其中的10改成0即可。但是即使这样设置后也是不能返回有重定向信息的Response，而是返回一个跳转停
止的error，不过如果你需要的只是带有重定向信息Response中的location信息的话只需要从返回的error中提取即可。http库
client中的doFollowingRedirects中传入了一个shouldRedirect函数，这个函数正是根据各种http协议的代码返回是否进行跳
转的信息，所以如果不改动这部分代码没法直接获取有重定向信息的Response，这样看来http库的设置不够灵活，得自己改或
另外实现了。

金玄

我正碰上这样的，问题。登录成功后不能进入登录后的页面，在抓包中才看到，我的User-Agent被改掉了，改成“Go 1.1 package http”了，弄得Session不可用。
如果我只想重设跳转后的Header的话，你有何办法提供吗？谢谢了。