Go语言如何实现类似Python functools.partial的重试包装逻辑？

Go里没有像Python functools.partial 那样直接的偏函数工具，但可以通过高阶函数+泛型实现类似的通用重试包装，同时还有一些贴合Go生态的特有重试模式可以利用。

一、通用重试包装（类似partial的思路） #

利用Go 1.18+的泛型，我们可以编写一个通用重试函数，适配不同参数和返回值的API函数。核心是用匿名函数绑定API的参数，生成一个符合重试函数要求的无参函数，以此模拟partial的参数绑定效果。

示例代码 #

假设我们有两个参数、返回值都不同的API函数：

type User struct {
    ID   int
    Name string
}

type Post struct {
    ID      int
    Title   string
    Content string
}

// 根据ID获取用户的API
func GetUser(id int) (User, error) {
    // 模拟随机失败的API调用
    if rand.Intn(3) == 0 {
        return User{}, fmt.Errorf("fetch user %d failed", id)
    }
    return User{ID: id, Name: "Alice"}, nil
}

// 创建文章的API
func CreatePost(title, content string) (Post, error) {
    if rand.Intn(3) == 0 {
        return Post{}, fmt.Errorf("create post '%s' failed", title)
    }
    return Post{ID: 123, Title: title, Content: content}, nil
}

接下来编写通用重试函数：

import (
    "fmt"
    "math/rand"
    "time"
)

// Retry 通用重试函数，支持任意返回值类型的函数
func Retry[T any](maxAttempts int, delay time.Duration, fn func() (T, error)) (T, error) {
    var result T
    for attempt := 1; attempt <= maxAttempts; attempt++ {
        var err error
        result, err = fn()
        if err == nil {
            return result, nil
        }
        fmt.Printf("Attempt %d failed: %v. Retrying in %v...\n", attempt, err, delay)
        time.Sleep(delay)
        // 可选：指数退避，每次重试延迟翻倍
        delay *= 2
    }
    return result, fmt.Errorf("all %d attempts failed: %v", maxAttempts, err)
}

然后用匿名函数绑定API参数，传入重试函数：

func main() {
    rand.Seed(time.Now().UnixNano())

    // 为GetUser绑定参数100，添加重试逻辑
    user, err := Retry(3, 1*time.Second, func() (User, error) {
        return GetUser(100)
    })
    if err != nil {
        fmt.Println("Get user failed:", err)
    } else {
        fmt.Println("Got user:", user)
    }

    // 为CreatePost绑定参数，添加重试逻辑
    post, err := Retry(3, 1*time.Second, func() (Post, error) {
        return CreatePost("Hello Go", "Retry example")
    })
    if err != nil {
        fmt.Println("Create post failed:", err)
    } else {
        fmt.Println("Created post:", post)
    }
}

二、Go特有的重试模式 #

1. 结合Context控制重试 #

Go中常用context.Context处理超时、取消逻辑，重试可以结合context实现更灵活的控制，比如上下文取消时立即终止重试：

import "context"

func RetryWithContext[T any](ctx context.Context, maxAttempts int, delay time.Duration, fn func() (T, error)) (T, error) {
    var result T
    for attempt := 1; attempt <= maxAttempts; attempt++ {
        select {
        case <-ctx.Done():
            return result, ctx.Err()
        default:
            var err error
            result, err = fn()
            if err == nil {
                return result, nil
            }
            fmt.Printf("Attempt %d failed: %v. Retrying in %v...\n", attempt, err, delay)
            time.Sleep(delay)
            delay *= 2
        }
    }
    return result, fmt.Errorf("all %d attempts failed: %v", maxAttempts, err)
}

使用时传入带超时的context：

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

user, err := RetryWithContext(ctx, 3, 1*time.Second, func() (User, error) {
    return GetUser(100)
})

2. 基于错误类型判断重试 #

Go的错误是值，我们可以自定义错误类型，只对临时错误（如网络波动、服务限流）进行重试：

// 自定义临时错误类型
type TemporaryError struct {
    Msg string
}

func (e *TemporaryError) Error() string {
    return e.Msg
}

// 标记该错误为临时可重试错误
func (e *TemporaryError) Temporary() bool {
    return true
}

// 只重试临时错误的重试函数
func RetryOnTempErr[T any](maxAttempts int, delay time.Duration, fn func() (T, error)) (T, error) {
    var result T
    for attempt := 1; attempt <= maxAttempts; attempt++ {
        var err error
        result, err = fn()
        if err == nil {
            return result, nil
        }
        // 判断是否为临时错误
        if tempErr, ok := err.(interface{ Temporary() bool }); ok && tempErr.Temporary() {
            fmt.Printf("Attempt %d failed (temporary): %v. Retrying in %v...\n", attempt, err, delay)
            time.Sleep(delay)
            delay *= 2
        } else {
            // 非临时错误，直接返回
            return result, err
        }
    }
    return result, fmt.Errorf("all %d attempts failed for temporary error: %v", maxAttempts, err)
}

修改API函数返回临时错误：

func GetUser(id int) (User, error) {
    if rand.Intn(3) == 0 {
        return User{}, &TemporaryError{Msg: fmt.Sprintf("fetch user %d failed (temporary)", id)}
    }
    return User{ID: id, Name: "Alice"}, nil
}

3. 结构体封装重试配置 #

如果需要复用复杂的重试策略（比如自定义延迟规则、日志格式），可以用结构体封装配置：

type RetryConfig struct {
    MaxAttempts  int
    InitialDelay time.Duration
    MaxDelay     time.Duration
}

func (c *RetryConfig) Retry[T any](fn func() (T, error)) (T, error) {
    var result T
    delay := c.InitialDelay
    for attempt := 1; attempt <= c.MaxAttempts; attempt++ {
        var err error
        result, err = fn()
        if err == nil {
            return result, nil
        }
        fmt.Printf("Attempt %d failed: %v. Retrying in %v...\n", attempt, err, delay)
        time.Sleep(delay)
        // 延迟不超过最大值
        if delay *= 2; delay > c.MaxDelay {
            delay = c.MaxDelay
        }
    }
    return result, fmt.Errorf("all %d attempts failed: %v", c.MaxAttempts, err)
}

使用时创建配置实例：

config := RetryConfig{
    MaxAttempts:  3,
    InitialDelay: 1 * time.Second,
    MaxDelay:     5 * time.Second,
}

user, err := config.Retry(func() (User, error) {
    return GetUser(100)
})

总结 #

• 用高阶函数+匿名函数可以模拟Python partial 的参数绑定效果，为不同API快速添加重试逻辑；
• 结合Go的context、自定义错误类型、结构体封装，能实现更贴合Go生态的灵活重试模式，提升代码的可维护性。

内容的提问来源于stack exchange，提问作者kxasha