重试http请求往返

我制作了一个服务器，客户端通过http连接。我在客户端的传输的RoundTripper方法中设置了重试机制。下面是每个服务器和客户端的工作代码示例：

服务器main.go

package main

import (
    "fmt"
    "net/http"
    "time"
)

func test(w http.ResponseWriter, req *http.Request) {
    time.Sleep(2 * time.Second)
    fmt.Fprintf(w, "hello\n")
}

func main() {
    http.HandleFunc("/test", test)
    http.ListenAndServe(":8090", nil)
}

客户端main.go

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "time"
)

type Retry struct {
    nums      int
    transport http.RoundTripper
}

// to retry
func (r *Retry) RoundTrip(req *http.Request) (resp *http.Response, err error) {
    for i := 0; i < r.nums; i++ {
        log.Println("Attempt: ", i+1)
        resp, err = r.transport.RoundTrip(req)
        if resp != nil && err == nil {
            return
        }
        log.Println("Retrying...")
    }
    return
}

func main() {
    r := &Retry{
        nums:      5,
        transport: http.DefaultTransport,
    }

    c := &http.Client{Transport: r}
    // each request will be timeout in 1 second
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://localhost:8090/test", nil)
    if err != nil {
        panic(err)
    }
    resp, err := c.Do(req)
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.StatusCode)
}

主程序包
进口(
“上下文”
“fmt”
“日志”
“net/http”
“时间”
)
类型重试结构{
nums int
传输http.RoundTripper
}
//重试
func（r*重试）往返（req*http.Request）（resp*http.Response，err error）{
对于i:=0；i

现在的情况是，重试似乎只适用于第一次迭代。对于后续的迭代，它不会每次等待一秒钟，而是打印调试消息，等待的时间与重试nums的时间相同

当我在上下文中放置超时1秒时，我希望重试尝试每次等待1秒。但整个重试过程似乎只需等待1秒。我错过了什么

---

此外，如何停止服务器处理超时请求？我看到

CloseNotifier

已经被弃用。

对于服务器，您可以使用

request.Context（）

检查请求是否被取消

在客户端，当上下文在1秒后超时时，请求超时。因此，上下文不会触发往返周期。如果希望在完成上下文之前重试请求，则应更改正在使用的传输的行为。您现在使用的是http.DefaultTransport，其定义如下：

var DefaultTransport往返程序=&Transport{
代理：ProxyFromEnvironment，
DialContext:（&net.Dialer）{
超时：30*次。秒，
保持生命：30*次。秒，
是的，
}).背景，
ForceAttemptHTTP2：正确，
MaxIdlecons:100，
IDlecontimeout:90*次。秒，
TLSHandshakeTimeout:10*次，秒，
ExpectContinueTimeout:1*次。秒，
}

---

传输

有更多的超时变量，这些变量在此处设置，因此根据您想重试的时间，您应该设置适当的超时。例如，在您的案例中，您可以将

Transport.ResponseHeaderTimeout

设置为1秒。当服务器在1秒内没有使用响应头进行响应时，客户端将重试。然后在5秒（或更好的6秒）后使上下文超时。您应该会看到客户端重试您指定的数量（5次）。

对于服务器，您可以使用

请求.context（）

检查请求是否被取消

在客户端，当上下文在1秒后超时时，请求超时。因此，上下文不会触发往返周期。如果希望在完成上下文之前重试请求，则应更改正在使用的传输的行为。您现在使用的是http.DefaultTransport，其定义如下：

var DefaultTransport往返程序=&Transport{
代理：ProxyFromEnvironment，
DialContext:（&net.Dialer）{
超时：30*次。秒，
保持生命：30*次。秒，
是的，
}).背景，
ForceAttemptHTTP2：正确，
MaxIdlecons:100，
IDlecontimeout:90*次。秒，
TLSHandshakeTimeout:10*次，秒，
ExpectContinueTimeout:1*次。秒，
}

---

传输

有更多的超时变量，这些变量在此处设置，因此根据您想重试的时间，您应该设置适当的超时。例如，在您的案例中，您可以将

Transport.ResponseHeaderTimeout

设置为1秒。当服务器在1秒内没有使用响应头进行响应时，客户端将重试。然后在5秒（或更好的6秒）后使上下文超时。您应该会看到客户端重试您指定的金额（5次）。

问题在于

上下文。一旦完成了上下文，就不能再重用相同的上下文。您必须在每次尝试时重新创建上下文。您可以从父上下文获取超时，并使用它创建新上下文

func (r *retry) RoundTrip(req *http.Request) (resp *http.Response, err error) {
    var (
        duration time.Duration
        ctx      context.Context
        cancel   func()
    )
    if deadline, ok := req.Context().Deadline(); ok {
        duration = time.Until(deadline)
    }
    for i := 0; i < r.nums; i++ {
        if duration > 0 {
            ctx, cancel = context.WithTimeout(context.Background(), duration)
            req = req.WithContext(ctx)
        }
        resp, err = r.rt.RoundTrip(req)
        ...
        // the rest of code
        ...
    }
    return
}

func（r*retry）往返（req*http.Request）（resp*http.Response，err error）{
变量(
持续时间，持续时间
上下文
取消func（）
)
如果是截止日期，确定：=req.Context（）.deadline（）；确定{
持续时间=截止时间（截止日期）
}
对于i:=0；i0{
ctx，cancel=context.WithTimeout（context.Background（），duration）
req=req.WithContext（ctx）
}
响应，err=r.rt.往返（req）
...
//代码的其余部分
...
}
返回
}

此代码每次尝试时都会使用其父级的超时创建新的新上下文。
问题在于
上下文。一旦完成了上下文，就不能再重用相同的上下文。您必须在每次尝试时重新创建上下文。您可以从父上下文获取超时，并使用它创建新上下文

func (r *retry) RoundTrip(req *http.Request) (resp *http.Response, err error) {
    var (
        duration time.Duration
        ctx      context.Context
        cancel   func()
    )
    if deadline, ok := req.Context().Deadline(); ok {
        duration = time.Until(deadline)
    }
    for i := 0; i < r.nums; i++ {
        if duration > 0 {
            ctx, cancel = context.WithTimeout(context.Background(), duration)
            req = req.WithContext(ctx)
        }
        resp, err = r.rt.RoundTrip(req)
        ...
        // the rest of code
        ...
    }
    return
}

func（r*retry）往返（req*http.Request）（resp*http.Response，err error）{
变量(
持续时间，持续时间
上下文
取消func（）
)