GO语言基础教程（130）Go错误处理之自定义错误信息：Go错误处理：别让你的error裸奔！—— 自定义错误让BUG无处可逃

一、Go的错误处理：简单到让人“抓狂”

每次看到Go官方那句“Errors are values”（错误就是值），我都想吐槽：这设计哲学也太直男了吧！就像你问男朋友“为什么迟到”，他回一句“迟到了”——，你知道出了问题，但完全不知道问题出在哪。

标准库的errors.New和fmt.Errorf确实简单，但简单过头了就变成了简陋：

err := errors.New("数据库连接失败")
// 然后呢？哪个数据库？什么参数？在哪行代码出的问题？

这感觉就像在医院听到医生喊：“那个生病的！过来一下！”——你根本不知道在叫谁啊！

但别急着骂Go的设计者，他们其实留了后门。错误接口长这样：

type error interface {
    Error() string
}

就这么简单！任何实现了Error() string的东西都是错误。这就给了我们无限的操作空间。

二、给错误“化妆”：从素颜到全妆的进化

2.1 基础版：给错误加“背景信息”

fmt.Errorf的%w动词是Go 1.13带来的神器，它能给错误穿上一层“透明外衣”：

func connectDB(host string) error {
    // 模拟连接失败
    return errors.New("connection refused")
}

func main() {
    err := connectDB("localhost:5432")
    if err != nil {
        wrappedErr := fmt.Errorf("数据库连接失败: %w, 主机: %s", err, "localhost:5432")
        fmt.Println(wrappedErr)
        // 输出：数据库连接失败: connection refused, 主机: localhost:5432
    }
}

这已经比裸错误好多了，但还有个问题：信息是写死的，不方便程序后续判断。

2.2 进阶版：创建会“说话”的错误类型

让我们创建一个“智能错误”，它不仅能告诉人类哪里出了问题，还能让程序读懂它：

// DBError 自定义数据库错误类型
type DBError struct {
    Op      string // 操作类型：connect、query、close等
    Host    string // 数据库地址
    Port    int    // 端口
    Message string // 原始错误信息
    Code    int    // 错误码，比如1连接失败、2查询超时
}

// 实现error接口
func (e *DBError) Error() string {
    return fmt.Sprintf("数据库操作[%s]失败，目标:%s:%d，错误码:%d，详情:%s", 
        e.Op, e.Host, e.Port, e.Code, e.Message)
}

// 判断是否是连接类错误
func (e *DBError) IsConnectionError() bool {
    return e.Code == 1
}

// 使用示例
func connectDB(host string, port int) error {
    // 模拟连接失败
    return &DBError{
        Op:      "connect", 
        Host:    host,
        Port:    port,
        Message: "connection timeout after 30s",
        Code:    1,
    }
}

func main() {
    err := connectDB("localhost", 5432)
    if err != nil {
        fmt.Println("捕获错误:", err)
        // 输出：捕获错误: 数据库操作[connect]失败，目标:localhost:5432，错误码:1，详情:connection timeout after 30s
        
        // 类型断言，获取详细信息
        if dbErr, ok := err.(*DBError); ok {
            if dbErr.IsConnectionError() {
                fmt.Println("这是个连接错误，需要重连机制！")
            }
            fmt.Printf("调试信息：在%s操作中，访问%s:%d出问题了\n", 
                dbErr.Op, dbErr.Host, dbErr.Port)
        }
    }
}

看到没？现在错误不仅会说话，还能回答特定问题了！这在写大型项目时特别有用。

三、错误也要“拉帮结派”：错误链与包装

在实际项目中，错误往往像滚雪球一样，从底层一直传递到上层。这时候就需要错误链：

package main

import (
    "errors"
    "fmt"
)

// 定义标准错误类型，方便判断
var (
    ErrDBNotFound = errors.New("数据库不存在")
    ErrTimeout    = errors.New("操作超时")
)

// QueryError 查询错误
type QueryError struct {
    SQL     string
    Message string
    Err     error // 底层错误
}

func (e *QueryError) Error() string {
    return fmt.Sprintf("SQL执行失败: %s, 错误: %v", e.SQL, e.Err)
}

func (e *QueryError) Unwrap() error {
    return e.Err
}

// 模拟底层数据库操作
func dbExec(sql string) error {
    // 模拟底层错误
    return ErrTimeout
}

// 业务层封装
func queryUser(id int) error {
    sql := fmt.Sprintf("SELECT * FROM users WHERE id = %d", id)
    
    if err := dbExec(sql); err != nil {
        return &QueryError{
            SQL:     sql,
            Message: "用户查询失败",
            Err:     err,
        }
    }
    return nil
}

func main() {
    err := queryUser(123)
    if err != nil {
        fmt.Println("最终错误:", err)
        
        // 使用errors.Is判断错误类型
        if errors.Is(err, ErrTimeout) {
            fmt.Println("根本原因是超时，应该启动重试机制")
        }
        
        // 遍历错误链
        current := err
        for current != nil {
            fmt.Printf("错误链节点: %s\n", current.Error())
            if unwrapped := errors.Unwrap(current); unwrapped != nil {
                current = unwrapped
            } else {
                break
            }
        }
    }
}

运行结果：

最终错误: SQL执行失败: SELECT * FROM users WHERE id = 123, 错误: 操作超时
根本原因是超时，应该启动重试机制
错误链节点: SQL执行失败: SELECT * FROM users WHERE id = 123, 错误: 操作超时
错误链节点: 操作超时

这就像侦探破案，从表面线索一直追溯到根本原因！

四、实战：构建企业级错误处理体系

光说不练假把式，来看一个完整的实战例子：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "time"
)

// AppError 应用级错误
type AppError struct {
    Timestamp time.Time // 时间戳
    File      string    // 文件名
    Line      int       // 行号
    Function  string    // 函数名
    Type      string    // 错误类型：db, network, biz等
    Code      string    // 错误代码
    Message   string    // 错误信息
    Cause     error     // 根本原因
    Context   map[string]interface{} // 上下文信息
}

func (e *AppError) Error() string {
    msg := fmt.Sprintf("[%s] %s: %s", e.Type, e.Code, e.Message)
    if e.Cause != nil {
        msg += fmt.Sprintf(" (原因: %v)", e.Cause)
    }
    return msg
}

func (e *AppError) Unwrap() error {
    return e.Cause
}

// 详细的JSON格式
func (e *AppError) ToJSON() string {
    data := map[string]interface{}{
        "timestamp": e.Timestamp.Format("2006-01-02 15:04:05"),
        "location":  fmt.Sprintf("%s:%d:%s", e.File, e.Line, e.Function),
        "type":      e.Type,
        "code":      e.Code,
        "message":   e.Message,
        "context":   e.Context,
    }
    if e.Cause != nil {
        data["cause"] = e.Cause.Error()
    }
    
    jsonData, _ := json.MarshalIndent(data, "", "  ")
    return string(jsonData)
}

// NewAppError 创建应用错误
func NewAppError(errType, code, message string, cause error) *AppError {
    // 在实际项目中，这里可以通过runtime.Caller自动获取调用信息
    return &AppError{
        Timestamp: time.Now(),
        Type:      errType,
        Code:      code,
        Message:   message,
        Cause:     cause,
        Context:   make(map[string]interface{}),
    }
}

// 模拟业务函数
func processOrder(orderID int) error {
    // 模拟验证订单
    if orderID <= 0 {
        err := NewAppError("biz", "INVALID_ORDER_ID", "订单ID不合法", nil)
        err.File = "order_service.go"
        err.Line = 42
        err.Function = "processOrder"
        err.Context["order_id"] = orderID
        err.Context["user_id"] = 1001
        return err
    }
    
    // 模拟数据库错误
    dbErr := NewAppError("db", "CONNECTION_TIMEOUT", "数据库连接超时", nil)
    dbErr.File = "db_client.go" 
    dbErr.Line = 88
    dbErr.Function = "queryOrder"
    dbErr.Context["timeout_seconds"] = 30
    dbErr.Context["db_host"] = "mysql-cluster-1"
    
    return dbErr
}

func main() {
    // 测试无效订单
    if err := processOrder(0); err != nil {
        log.Printf("业务错误: %v\n", err)
        if appErr, ok := err.(*AppError); ok {
            fmt.Println("详细错误信息(JSON):")
            fmt.Println(appErr.ToJSON())
        }
    }
    
    fmt.Println("\n" + "="*50 + "\n")
    
    // 测试数据库错误
    if err := processOrder(123); err != nil {
        log.Printf("系统错误: %v\n", err)
        if appErr, ok := err.(*AppError); ok {
            fmt.Println("详细错误信息(JSON):")
            fmt.Println(appErr.ToJSON())
        }
    }
}

运行这个程序，你会看到格式优美的错误输出，包含时间、位置、类型、上下文等所有调试需要的信息。

五、错误处理的最佳实践（避坑指南）

不要过度包装：错误包装2-3层就够了，再多就成俄罗斯套娃了
提供恢复上下文：

func recoverFromPanic() {
    if r := recover(); r != nil {
        err := NewAppError("panic", "UNEXPECTED_PANIC", "程序发生panic", nil)
        err.Context["panic_value"] = r
        // 发送到监控系统
        sendToMonitoring(err.ToJSON())
    }
}

错误要可判断：

// 定义可判断的错误
var ErrUserNotFound = errors.New("用户不存在")

// 使用
if errors.Is(err, ErrUserNotFound) {
    return 404 // HTTP状态码
}

日志与错误分离：错误对象只包含必要信息，详细的调试信息交给日志系统

六、总结

Go的错误处理就像吃辣椒——开始觉得太直接有点受不了，但掌握自定义错误后，你会发现这种设计其实很优雅。

记住几个关键点：

简单错误用fmt.Errorf包装
复杂场景定义错误类型
错误链不要超过3层
让错误既被人读懂也被程序读懂

现在，给你的错误信息穿上合适的"衣服"，别让它们在日志里"裸奔"了！完整的示例代码已经在上面，赶紧抄作业去吧～

扩展思考：在你的项目中，哪些模糊的错误信息最让人头疼？试着用今天学的方法改造它们，调试效率会有立竿见影的提升！