Golang 错误处理最佳实践与emperror库使用指南

Go错误处理最佳实践

1. 错误处理基本原则

1. 始终检查错误：不要忽略返回的错误值
2. 提供有意义的错误信息：错误应该包含足够上下文
3. 错误类型判断：使用errors.Is和errors.As进行错误类型判断
4. 错误包装：使用fmt.Errorf和%w动词包装错误
5. 避免过度包装：不要创建过深的错误链

2. 错误处理示例

package main

import (
	"errors"
	"fmt"
	"os"
)

var ErrFileNotFound = errors.New("file not found")

func readFile(path string) ([]byte, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			return nil, fmt.Errorf("%w: %s", ErrFileNotFound, path)
		}
		return nil, fmt.Errorf("failed to read file: %w", err)
	}
	return data, nil
}

func main() {
	data, err := readFile("nonexistent.txt")
	if err != nil {
		if errors.Is(err, ErrFileNotFound) {
			fmt.Println("处理文件未找到错误:", err)
		} else {
			fmt.Println("其他错误:", err)
		}
		os.Exit(1)
	}
	fmt.Println("文件内容:", string(data))
}

emperror库介绍

emperror是一个强大的Go错误处理库，提供了错误处理、日志记录和监控的集成方案。

1. emperror核心功能

• 错误处理中间件
• 错误日志记录
• 错误监控集成
• 上下文支持
• 多种错误处理器

2. 安装emperror

go get github.com/emperror/emperror

3. emperror使用示例

基本使用

package main

import (
	"errors"
	"fmt"
	"log"

	"github.com/emperror/emperror"
)

func main() {
	// 创建错误处理器
	handler := emperror.NewErrorHandler(
		emperror.WithHandler(
			func(err error) {
				log.Printf("处理错误: %v", err)
			},
		),
	)

	// 使用错误处理器
	err := errors.New("示例错误")
	handler.Handle(err)

	// 带上下文的错误处理
	ctxHandler := emperror.NewErrorHandler(
		emperror.WithContext(
			map[string]interface{}{
				"service": "example",
				"version": "1.0",
			},
		),
		emperror.WithHandler(
			func(err error) {
				log.Printf("带上下文的错误: %v", err)
			},
		),
	)

	ctxHandler.Handle(fmt.Errorf("带上下文的错误: %w", err))
}

集成日志记录

package main

import (
	"errors"

	"github.com/emperror/emperror"
	"github.com/emperror/emperror/logur"
	"github.com/sirupsen/logrus"
)

func main() {
	// 创建logrus日志记录器
	logger := logrus.New()

	// 将logrus适配到logur接口
	loggerAdapter := logur.NewLogrusLogger(logger)

	// 创建错误处理器
	handler := emperror.NewErrorHandler(
		emperror.WithLogger(loggerAdapter),
	)

	// 处理错误
	err := errors.New("数据库连接失败")
	handler.Handle(err)
}

错误监控集成

package main

import (
	"errors"

	"github.com/emperror/emperror"
	"github.com/emperror/emperror/handler/sentry"
	"github.com/getsentry/sentry-go"
)

func main() {
	// 初始化Sentry
	err := sentry.Init(sentry.ClientOptions{
		Dsn: "your-sentry-dsn",
	})
	if err != nil {
		panic(err)
	}

	// 创建Sentry错误处理器
	sentryHandler := sentry.New()

	// 创建emperror处理器
	handler := emperror.NewErrorHandler(
		emperror.WithHandler(sentryHandler),
	)

	// 处理错误
	err = errors.New("关键业务错误")
	handler.Handle(err)
}

4. emperror高级特性

多错误处理器

package main

import (
	"errors"
	"log"

	"github.com/emperror/emperror"
	"github.com/emperror/emperror/handler/multi"
)

func main() {
	// 创建多个错误处理器
	handlers := multi.New(
		// 日志处理器
		emperror.HandlerFunc(func(err error) {
			log.Printf("日志记录错误: %v", err)
		}),
		// 监控处理器
		emperror.HandlerFunc(func(err error) {
			log.Printf("发送到监控系统: %v", err)
		}),
	)

	// 创建emperror处理器
	handler := emperror.NewErrorHandler(
		emperror.WithHandler(handlers),
	)

	// 处理错误
	err := errors.New("多处理器测试错误")
	handler.Handle(err)
}

错误过滤

package main

import (
	"errors"

	"github.com/emperror/emperror"
	"github.com/emperror/emperror/handler/ignore"
)

var ErrIgnorable = errors.New("可忽略的错误")

func main() {
	// 创建忽略特定错误的处理器
	ignoreHandler := ignore.New(ErrIgnorable)

	// 创建emperror处理器
	handler := emperror.NewErrorHandler(
		emperror.WithHandler(ignoreHandler),
		emperror.WithHandler(
			emperror.HandlerFunc(func(err error) {
				if !errors.Is(err, ErrIgnorable) {
					println("处理非忽略错误:", err.Error())
				}
			}),
		),
	)

	// 处理可忽略错误
	handler.Handle(ErrIgnorable)

	// 处理不可忽略错误
	handler.Handle(errors.New("重要错误"))
}

总结

1. Go的错误处理应该遵循明确的原则，提供足够的上下文信息
2. emperror提供了强大的错误处理基础设施，可以轻松集成日志、监控等系统
3. 通过emperror可以实现错误处理的统一管理和策略配置
4. 结合errors包的Is/As方法，可以构建健壮的错误处理系统

对于大型项目，使用emperror可以显著提高错误处理的规范性和可维护性，同时便于集中监控和日志记录。