How to use Golang to implement the retry mechanism of HTTP file upload?

Use Go to implement the HTTP file upload retry mechanism: use the Client.Do() method to send a request. Waits for the specified number of seconds (retryWaitSeconds) when an error occurs. Retry maxRetries times. If the maximum number of retries is reached, the error "maximum retries exceeded" is returned.

How to use Go to implement the retry mechanism of HTTP file upload

When building a distributed system, HTTP file upload is reliable Sex is crucial. When the network connection is unstable or the server is temporarily unavailable, the retry mechanism can help ensure that files are uploaded successfully.

Use Go to implement the retry mechanism

Go provides a built-in net/http package, which contains Client Type that can be used to perform HTTP requests. We can use the Client.Do() method to send a request and retry it when an error occurs.

The following are the steps to implement the retry mechanism:

import (
    "context"
    "errors"
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
    "strconv"
    "time"
)

// 重试前等待的时间，单位秒
var retryWaitSeconds = 5

// 最大重试次数
var maxRetries = 3

// UploadFileWithRetry 发送文件并重试失败的请求
func UploadFileWithRetry(ctx context.Context, client *http.Client, url string, file io.Reader) (string, error) {
    var err error

    for i := 0; i <= maxRetries; i++ {
        // 发送请求
        req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, file)
        if err != nil {
            return "", fmt.Errorf("create request: %w", err)
        }

        resp, err := client.Do(req)
        if err != nil {
            if i == maxRetries {
                return "", fmt.Errorf("client do: %w", err)
            }
            time.Sleep(time.Second * time.Duration(retryWaitSeconds))
            continue
        }

        defer resp.Body.Close()

        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            return "", fmt.Errorf("read response: %w", err)
        }

        if resp.StatusCode != http.StatusOK {
            if i == maxRetries {
                return "", fmt.Errorf("unexpected response: %s %s", resp.Status, string(body))
            }
            time.Sleep(time.Second * time.Duration(retryWaitSeconds))
            continue
        }

        return string(body), nil
    }

    return "", errors.New("maximum retries exceeded")
}

Practical case

The following is a function using UploadFileWithRetry() Example of uploading files:

func main() {
    ctx := context.Background()
    client := &http.Client{}
    url := "https://example.com/upload"
    file, err := os.Open("test.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    body, err := UploadFileWithRetry(ctx, client, url, file)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("File uploaded successfully:", body)
}

By using this retry mechanism, we are able to ensure reliable file uploads in the event of network or server issues, thereby improving the robustness of the application.

The above is the detailed content of How to use Golang to implement the retry mechanism of HTTP file upload?. For more information, please follow other related articles on the PHP Chinese website!