Go net/http:http:ContentLength=222，正文长度为0

如果存在连接/代理错误，我将尝试重试请求。出于某些原因，我不断收到此错误，无论重试请求的尝试如何，该错误似乎都无法恢复：

    Post https://m.somewebsite.co.uk/api/di/34433: http: ContentLength=222  with Body length 0

我做错什么了吗？我的第一个怀疑是http.Request不知何故被消耗了，所以在下一次尝试时，它不再是好的。我应该复印一份吗

func Post(URL string, form url.Values, cl *http.Client) ([]byte, error) {
    req, err := http.NewRequest("POST", URL, strings.NewReader(form.Encode()))
    if err != nil {
        log.Error(err)
        return nil, err
    }
    req.Header.Set("User-Agent", ua)
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    rsp, err := do(cl, req)

    if err != nil {
        return nil, err
    }
    defer rsp.Body.Close()
    b, err := ioutil.ReadAll(rsp.Body)
    if err != nil {
        log.Error(err)
        return nil, err
    }

    return b, nil
}

func do(cl *http.Client, req *http.Request)(*http.Response, error){
    rsp, err := cl.Do(req)
    for i := 0; IsErrProxy(err); i++ {
        log.Errorf("Proxy is slow or down ")
        time.Sleep(6 * time.Second)
5t      rsp, err = cl.Do(&ncp)
        if err == nil{
            return rsp, nil
        }
        if i > 10 {

            return nil, fmt.Errorf("after %v tries error: %v", i, err)
        }
    }
    return rsp, err
}

---

问题在于，在第一次调用Do（）时，请求正文被读取到末尾。在后续调用Do（）时，不会从响应体读取任何数据

修复方法是将主体读取器的创建移动到for循环中。这需要在for循环内创建请求

func Post(URL string, form url.Values, cl *http.Client) ([]byte, error) {
  body := form.Encode()
  for i := 0; i < 10; i++ {
    req, err := http.NewRequest("POST", URL, strings.NewReader(body))
    if err != nil {
        log.Error(err)
        return nil, err
    }
    req.Header.Set("User-Agent", ua)
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    rsp, err := cl.Do(req)
    if err == nil {
        defer rsp.Body.Close()
        b, err := ioutil.ReadAll(rsp.Body)
        if err != nil {
            log.Error(err)
            return nil, err
        }
        return b, nil
    }

    if !IsErrorProxy(err) {
        return nil, err
    }

    log.Errorf("Proxy is slow or down ")
    time.Sleep(6 * time.Second)
  }
  return nil, fmt.Errorf("after 10 tries error: %v", err)
}

func Post（URL字符串，表单URL.Values，cl*http.Client）（[]字节，错误）{
body:=form.Encode（）
对于i:=0；i<10；i++{
req，err:=http.NewRequest（“POST”，URL，strings.NewReader（body））
如果错误！=零{
日志错误（err）
返回零，错误
}
请求头集合（“用户代理”，ua）
req.Header.Set（“内容类型”、“应用程序/x-www-form-urlencoded”）
rsp，err:=cl.Do（要求）
如果err==nil{
延迟rsp.Body.Close（）
b、 err:=ioutil.ReadAll（rsp.Body）
如果错误！=零{
日志错误（err）
返回零，错误
}
返回b，无
}
if！iErrorProxy（错误）{
返回零，错误
}
log.Errorf（“代理速度慢或慢”）
时间。睡眠（6*时间。秒）
}
返回nil，fmt.Errorf（“尝试10次后错误：%v”，err）
}

让我们看看

http.NewRequest

做了什么

rc, ok := body.(io.ReadCloser)
if !ok && body != nil {
    rc = ioutil.NopCloser(body)
}
// The host's colon:port should be normalized. See Issue 14836.
u.Host = removeEmptyPort(u.Host)
req := &Request{
    Method:     method,
    URL:        u,
    Proto:      "HTTP/1.1",
    ProtoMajor: 1,
    ProtoMinor: 1,
    Header:     make(Header),
    Body:       rc,
    Host:       u.Host,
}

body

是

io.Reader

的类型，并通过

ioutil.nocloser

转换为

io.ReaderCloser

。正如@Cerise Limón所说，Request.Body已被读取，流更近，因此当您再次

Do（）

时，

Body长度

为0

因此，我们可以在调用

Do

之前重置Request.Body

func Post(URL string, form url.Values, cl *http.Client) ([]byte, error) {
    requestBodyString := form.Encode()
    req, err := http.NewRequest("POST", URL, strings.NewReader(requestBodyString))
    // ...

    rsp, err := do(cl, req, requestBodyString)

    //...
    return b, nil
}

func do(cl *http.Client, req *http.Request, requestBodyString string)(*http.Response, error){
    rsp, err := cl.Do(req)
    for i := 0; IsErrProxy(err); i++ {
        log.Errorf("Proxy is slow or down ")
        time.Sleep(6 * time.Second)
        // reset Request.Body
        req.Body = ioutil.NopCloser(strings.NewReader(requestBodyString))
        rsp, err = cl.Do(&req)
        if err == nil{
            return rsp, nil
        }
        if i > 10 {

            return nil, fmt.Errorf("after %v tries error: %v", i, err)
        }
    }
    return rsp, err
}

---

我找到了一种不用每次都重新创建请求的方法。下面是一个示例代码，它是@Cerise Limón的一个非常轻微的修改，与@Rambo的代码类似，它只创建一次请求：

func Post(URL string, data *bytes.Buffer, cl *http.Client) ([]byte, error) {
    var err error

    req, err := http.NewRequest("POST", URL, ioutil.NopCloser(data))
    if err != nil {
        log.Errorf("Unable to create the request: %v", err)
        return nil, err
    }
    req.Header.Set("User-Agent", ua)

    for i := 0; i < 10; i++ {
        rsp, err := cl.Do(req)
        if err == nil && rsp.StatusCode == 200 {
            defer rsp.Body.Close()
            b, err := ioutil.ReadAll(rsp.Body)
            if err != nil {
                fmt.Printf("Error: %v", err)
                return nil, err
            }
            return b, nil
        }

        log.Errorf("Proxy is slow or down %v", err)
        time.Sleep(1 * time.Second)
    }
    return nil, fmt.Errorf("after 10 tries error: %v", err)
}

func main() {
    client := http.Client{}
    data := []byte{0, 1, 2, 3, 4}
    Post("http://server/my/api/resource/", bytes.NewBuffer(data), &client)
}

func Post（URL字符串，数据*bytes.Buffer，cl*http.Client）（[]字节，错误）{
变量错误
req，err:=http.NewRequest（“POST”，URL，ioutil.nocloser（数据））
如果错误！=零{
log.Errorf（“无法创建请求：%v”，错误）
返回零，错误
}
请求头集合（“用户代理”，ua）
对于i:=0；i<10；i++{
rsp，err:=cl.Do（要求）
如果err==nil&&rsp.StatusCode==200{
延迟rsp.Body.Close（）
b、 err:=ioutil.ReadAll（rsp.Body）
如果错误！=零{
fmt.Printf（“错误：%v”，错误）
返回零，错误
}
返回b，无
}
log.Errorf（“代理速度慢或慢%v”，err）
时间。睡眠（1*时间。秒）
}
返回nil，fmt.Errorf（“尝试10次后错误：%v”，err）
}
func main（）{
客户端：=http.client{}
数据：=[]字节{0,1,2,3,4}
职位（”http://server/my/api/resource/，bytes.NewBuffer（数据），&客户端）
}