使用 robustly 实现 Golang 函数异常捕获与自动恢复

robustly 是一个轻量级的 Golang 库，用于捕获函数执行过程中的 panic 并自动恢复，同时提供错误处理和重试机制。下面我将详细介绍如何使用这个库。

安装 robustly

首先安装 robustly 库：

go get github.com/VividCortex/robustly

基本用法

1. 简单的 panic 捕获

package main

import (
	"fmt"
	"github.com/VividCortex/robustly"
)

func dangerousFunction() {
	fmt.Println("准备执行危险操作")
	panic("发生了一个严重的错误!")
}

func main() {
	// 使用 robustly 包装函数
	err := robustly.Run(dangerousFunction)
	if err != nil {
		fmt.Printf("捕获到错误: %v\n", err)
	}
	fmt.Println("程序继续执行")
}

输出结果：

准备执行危险操作
捕获到错误: 发生了一个严重的错误!
程序继续执行

2. 带返回值的函数处理

func divide(a, b int) (int, error) {
	if b == 0 {
		panic("除数不能为零")
	}
	return a / b, nil
}

func main() {
	result, err := robustly.RunFn(func() (interface{}, error) {
		return divide(10, 0)
	})
	
	if err != nil {
		fmt.Printf("计算失败: %v\n", err)
	} else {
		fmt.Printf("计算结果: %d\n", result.(int))
	}
}

高级功能

1. 重试机制

func unreliableService() error {
	// 模拟有时会失败的服务
	if rand.Intn(2) == 0 {
		return fmt.Errorf("服务暂时不可用")
	}
	return nil
}

func main() {
	// 最多重试3次，每次间隔1秒
	retryOpts := &robustly.RetryOptions{
		MaxRetries: 3,
		Delay:      time.Second,
	}
	
	err := robustly.RunWithOptions(
		func() error { return unreliableService() },
		&robustly.Options{Retry: retryOpts},
	)
	
	if err != nil {
		fmt.Printf("最终失败: %v\n", err)
	} else {
		fmt.Println("操作成功")
	}
}

2. 自定义错误处理

func main() {
	opts := &robustly.Options{
		OnError: func(err error) {
			fmt.Printf("自定义错误处理: %v\n", err)
			// 可以在这里添加日志记录、监控上报等逻辑
		},
	}
	
	err := robustly.RunWithOptions(
		func() error {
			panic("测试自定义错误处理")
			return nil
		},
		opts,
	)
	
	if err != nil {
		fmt.Println("主流程知道发生了错误")
	}
}

3. 超时控制

func longRunningTask() {
	time.Sleep(2 * time.Second)
	fmt.Println("任务完成")
}

func main() {
	opts := &robustly.Options{
		Timeout: time.Second,
	}
	
	err := robustly.RunWithOptions(longRunningTask, opts)
	if err != nil {
		fmt.Printf("任务超时: %v\n", err)
	}
}

实际应用示例

HTTP 服务中的使用

package main

import (
	"fmt"
	"net/http"
	"github.com/VividCortex/robustly"
)

func riskyHandler(w http.ResponseWriter, r *http.Request) {
	// 可能panic的操作
	if r.URL.Path == "/panic" {
		panic("故意触发的panic")
	}
	fmt.Fprintf(w, "请求处理成功: %s", r.URL.Path)
}

func main() {
	// 包装处理函数
	safeHandler := func(w http.ResponseWriter, r *http.Request) {
		err := robustly.Run(func() {
			riskyHandler(w, r)
		})
		
		if err != nil {
			http.Error(w, "服务器内部错误", http.StatusInternalServerError)
			fmt.Printf("处理请求时出错: %v\n", err)
		}
	}
	
	http.HandleFunc("/", safeHandler)
	fmt.Println("服务启动在 :8080")
	http.ListenAndServe(":8080", nil)
}

注意事项

1. robustly 不能捕获所有类型的 panic，特别是 Go 运行时的一些严重错误（如内存不足）
2. 在 defer 中再次 panic 可能会导致 robustly 无法捕获
3. 对于性能敏感的场景，频繁 panic 会影响性能
4. 不要过度依赖 panic 捕获，良好的错误处理应该是首选

robustly 提供了一种简单有效的方式来增强程序的健壮性，特别是在处理第三方库或不可靠的外部服务时特别有用。