在Golang的编程实践中，错误处理是程序健壮性的重要保障。当业务场景需要执行多个可能返回错误的操作时，比如批量处理数据、调用多个下游接口、执行多步文件操作等，单一的错误返回机制无法完整记录所有出错信息，这就需要合理的多重错误处理策略来组合和报告错误。
多重错误处理的常见场景
以下场景通常需要处理多个错误：
- 批量操作场景：比如批量插入数据库记录，部分记录插入失败需要记录所有失败的记录信息
- 多步骤流程场景：比如用户注册流程需要校验参数、检查账号是否存在、发送验证码，每一步都可能出错
- 并发操作场景：多个goroutine同时执行任务，需要收集所有goroutine返回的错误
基础错误组合策略
使用切片收集错误
最基础的多重错误处理方式是使用错误切片收集所有错误，最后统一判断是否有错误发生。这种方式实现简单，适合错误之间没有依赖关系的场景。
package main
import (
"errors"
"fmt"
)
// 模拟批量处理函数，返回所有错误
func batchProcess(items []int) []error {
var errs []error
for _, item := range items {
// 模拟部分item处理失败
if item%2 == 0 {
errs = append(errs, fmt.Errorf("item %d 处理失败: 数值为偶数", item))
}
}
return errs
}
func main() {
items := []int{1, 2, 3, 4, 5}
errs := batchProcess(items)
if len(errs) > 0 {
// 报告所有错误
for _, err := range errs {
fmt.Println(err)
}
}
}
自定义错误组合类型
如果需要在错误中保留更多上下文信息，或者需要统一错误报告格式，可以自定义实现error接口的组合错误类型。自定义类型可以支持错误计数、按类别分类错误等功能。
package main
import (
"fmt"
"strings"
)
// MultiError 自定义多重错误类型
type MultiError struct {
errs []error
}
// Add 添加错误到集合中
func (m *MultiError) Add(err error) {
if err != nil {
m.errs = append(m.errs, err)
}
}
// Error 实现error接口，返回所有错误的拼接字符串
func (m *MultiError) Error() string {
if len(m.errs) == 0 {
return ""
}
var errMsgs []string
for _, err := range m.errs {
errMsgs = append(errMsgs, err.Error())
}
return fmt.Sprintf("共发生 %d 个错误: %s", len(m.errs), strings.Join(errMsgs, "; "))
}
// HasError 判断是否存在错误
func (m *MultiError) HasError() bool {
return len(m.errs) > 0
}
func main() {
var multiErr MultiError
// 模拟多个操作
multiErr.Add(fmt.Errorf("数据库连接失败"))
multiErr.Add(fmt.Errorf("参数校验不通过: 用户名为空"))
multiErr.Add(fmt.Errorf("缓存写入失败"))
if multiErr.HasError() {
fmt.Println(multiErr.Error())
}
}
带上下文的多重错误处理
在实际排查问题时，仅知道错误内容往往不够，还需要知道错误发生的位置、相关的参数等上下文信息。可以在组合错误时保留上下文，方便后续定位问题。
package main
import (
"fmt"
"strings"
)
// ContextError 带上下文的单个错误
type ContextError struct {
Ctx string // 错误发生的上下文描述
Err error // 原始错误
}
// Error 实现error接口
func (c *ContextError) Error() string {
return fmt.Sprintf("[%s] %s", c.Ctx, c.Err.Error())
}
// Unwrap 支持错误链展开
func (c *ContextError) Unwrap() error {
return c.Err
}
// ContextMultiError 带上下文的多重错误类型
type ContextMultiError struct {
errs []*ContextError
}
func (c *ContextMultiError) Add(ctx string, err error) {
if err != nil {
c.errs = append(c.errs, &ContextError{
Ctx: ctx,
Err: err,
})
}
}
func (c *ContextMultiError) Error() string {
if len(c.errs) == 0 {
return ""
}
var parts []string
for _, e := range c.errs {
parts = append(parts, e.Error())
}
return strings.Join(parts, "n")
}
func main() {
var cmErr ContextMultiError
// 不同步骤的错误添加对应上下文
cmErr.Add("用户注册-参数校验", fmt.Errorf("手机号格式不正确"))
cmErr.Add("用户注册-账号检查", fmt.Errorf("账号已存在"))
cmErr.Add("用户注册-验证码校验", fmt.Errorf("验证码已过期"))
if len(cmErr.errs) > 0 {
fmt.Println("用户注册失败，错误详情:")
fmt.Println(cmErr.Error())
}
}
并发场景下的多重错误处理
当多个goroutine同时执行任务时，需要安全的收集各个goroutine返回的错误，避免并发写入错误切片导致的数据竞争问题。可以结合sync.WaitGroup和sync.Mutex实现安全的错误收集。
package main
import (
"fmt"
"sync"
)
func task(id int, wg *sync.WaitGroup, mu *sync.Mutex, errs *[]error) {
defer wg.Done()
// 模拟部分任务失败
if id%3 == 0 {
mu.Lock()
*errs = append(*errs, fmt.Errorf("任务 %d 执行失败: 超时", id))
mu.Unlock()
}
}
func main() {
var wg sync.WaitGroup
var mu sync.Mutex
var errs []error
// 启动5个并发任务
for i := 1; i <= 5; i++ {
wg.Add(1)
go task(i, &wg, &mu, &errs)
}
wg.Wait()
if len(errs) > 0 {
fmt.Println("并发任务执行完成，存在错误:")
for _, err := range errs {
fmt.Println(err)
}
} else {
fmt.Println("所有并发任务执行成功")
}
}
错误报告的最佳实践
在报告多重错误时，需要遵循以下原则提升错误信息的可用性：
- 保留错误发生的顺序，方便对应业务执行流程排查问题
- 避免错误信息的冗余，相同类型的错误可以适当合并
- 对于需要上报到监控系统的错误，可以结构化错误类型，方便后续统计
- 敏感信息不要出现在错误报告中，比如用户密码、内部接口地址等
通过合理的多重错误处理策略，开发者可以在Golang程序中完整记录所有出错信息，既不会因为丢失错误导致问题排查困难，也不会因为错误信息混乱增加维护成本。根据具体的业务场景选择合适的组合和报告方式，能够显著提升程序的健壮性和可维护性。