Golang网络请求错误捕获与处理技巧

if err != nil

error

nil

nil

net

net.Error

Timeout()

Temporary()

os

os.IsTimeout(err)

os.IsTemporary(err)

package main

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

func makeRequest() error {
    client := &http.Client{
        Timeout: 5 * time.Second, // 设置一个短一点的超时
    }
    // 尝试请求一个可能不存在或响应慢的地址
    resp, err := client.Get("http://localhost:9999/some-path") 
    if err != nil {
        // 判断是否是网络错误
        if netErr, ok := err.(net.Error); ok {
            if netErr.Timeout() {
                fmt.Println("Error: 请求超时了！")
                return err
            }
            if netErr.Temporary() {
                fmt.Println("Error: 这是一个临时性网络错误，可以考虑重试。")
                return err
            }
        }

        // 使用 os 包的辅助函数
        if os.IsTimeout(err) {
            fmt.Println("Error: (os.IsTimeout) 请求超时了！")
            return err
        }
        if os.IsTemporary(err) {
            fmt.Println("Error: (os.IsTemporary) 这是一个临时性错误，可以重试。")
            return err
        }

        // 其他常见错误判断
        if _, ok := err.(*net.OpError); ok {
            // net.OpError 包含了许多底层网络操作错误，比如连接拒绝、DNS查找失败等
            fmt.Printf("Error: 这是一个网络操作错误 (%T): %v\n", err, err)
            // 可以进一步检查 err.Op、err.Net、err.Addr 等字段
            // 例如，连接拒绝通常会包含 "connection refused" 字符串
            if cErr, ok := err.(*net.OpError); ok && cErr.Op == "dial" {
                if serr, ok := cErr.Err.(*os.SyscallError); ok && serr.Syscall == "connect" {
                    fmt.Println("具体错误：连接被拒绝了！")
                }
            }
            return err
        }

        // 更多错误类型，例如io.EOF可能表示服务器过早关闭连接
        if err == io.EOF {
            fmt.Println("Error: 服务器在响应完成前关闭了连接 (EOF)。")
            return err
        }

        fmt.Printf("Error: 未知错误类型: %v\n", err)
        return err
    }
    defer resp.Body.Close()
    fmt.Printf("Request successful, status: %s\n", resp.Status)
    return nil
}

func main() {
    fmt.Println("尝试模拟一个超时或连接拒绝的请求...")
    makeRequest()
}

os

context

package main

import (
    "context"
    "fmt"
    "math/rand"
    "net/http"
    "time"
)

// simulateNetworkRequest 模拟一个可能失败的网络请求
func simulateNetworkRequest(attempt int) error {
    // 假设前几次请求会失败
    if attempt < 3 { 
        return fmt.Errorf("模拟请求失败，尝试次数: %d", attempt+1)
    }
    fmt.Printf("模拟请求成功，尝试次数: %d\n", attempt+1)
    return nil
}

// WithExponentialBackoffRetries 带有指数退避和抖动的重试函数
func WithExponentialBackoffRetries(ctx context.Context, maxRetries int, initialDelay time.Duration, op func(attempt int) error) error {
    var err error
    for i := 0; i < maxRetries; i++ {
        select {
        case <-ctx.Done():
            fmt.Println("Context 被取消，停止重试。")
            return ctx.Err()
        default:
            // 执行操作
            err = op(i)
            if err == nil {
                return nil // 成功，直接返回
            }

            fmt.Printf("尝试 %d 失败: %v\n", i+1, err)

            // 计算退避时间
            delay := initialDelay * time.Duration(1<<uint(i)) // 1s, 2s, 4s, 8s...

            // 添加抖动，避免“惊群效应”
            jitter := time.Duration(rand.Int63n(int64(delay / 2))) // 随机抖动，最大为 delay/2
            delay = delay + jitter

            fmt.Printf("等待 %v 后重试...\n", delay)
            time.Sleep(delay)
        }
    }
    return fmt.Errorf("重试 %d 次后仍然失败: %w", maxRetries, err)
}

func main() {
    rand.Seed(time.Now().UnixNano()) // 初始化随机数种子

    ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
    defer cancel()

    fmt.Println("开始进行带有指数退避和抖动的重试...")
    err := WithExponentialBackoffRetries(ctx, 5, 1*time.Second, simulateNetworkRequest)
    if err != nil {
        fmt.Printf("最终结果: %v\n", err)
    } else {
        fmt.Println("最终结果: 操作成功！")
    }

    // 模拟一个请求，但context提前取消
    fmt.Println("\n模拟一个context提前取消的重试...")
    ctx2, cancel2 := context.WithCancel(context.Background())
    go func() {
        time.Sleep(3 * time.Second) // 3秒后取消context
        cancel2()
    }()
    err2 := WithExponentialBackoffRetries(ctx2, 5, 1*time.Second, simulateNetworkRequest)
    if err2 != nil {
        fmt.Printf("最终结果: %v\n", err2)
    }
}

WithExponentialBackoffRetries

context