Question

我想知道在go 中处理多级抽象错误的最佳方法是什么。每次如果我必须在程序中添加新的级别抽象，我就不得不将错误代码从级别转移到级别高。因此是日志文件中的重复社区或我必须重新删除通信表单级别并将其转移到更高级别。以下简单示例。我跳过创建每个对象更快和celar代码，但我认为你理解我的问题

type ObjectOne struct{
    someValue int
}

func (o* ObjectOne)CheckValue()error{
    if o.someValue == 0 {
        SomeLogger.Printf("Value is 0 error program") // communicate form first level abstraction to logger
        return errors.New("Internal value in object is 0")
    }
    return nil
}

type ObjectTwoHigherLevel struct{
    objectOne ObjectOne
}

func (oT*  ObjectTwoHigherLevel)CheckObjectOneIsReady() error{
    if err := oT.objectOne.CheckValue() ; err != nil{
        SomeLogger.Printf("Value in objectOne is not correct for objectTwo %s" , err) //  second communicate
        return  err
    }
    return nil
}

type ObjectThreeHiggerLevel struct{
    oT ObjectTwoHigherLevel
}

func (oTh* ObjectThreeHiggerLevel)CheckObjectTwoIsReady()error{
    if err := oTh.oT.CheckObjectOneIsReady() ; err != nil{
        SomeLogger.Printf("Value in objectTwo is not correct for objectThree %s" , err)
    return err
    }
    return nil
}

结果在日志文件中我得到重复的帖子

Value is 0 error program 
Value in objectOne is not correct for objectTwo Internal value in object is 0 
Value in objectTwo is not correct for objectThree Internal value in object is 0

反过来，如果我只将一些err转移到更高级别而没有额外的日志，我会丢失每个级别发生的信息。

这怎么解决？ privent复制如何通信？或者我的方式是好的和唯一的？

如果我在一些抽象级别上创建一些在数据库中搜索某些东西的对象，那么问题会更令人沮丧，然后我在logFile中也会形成相同任务的几行。

Answer 1

您应该处理错误，或者不处理错误，但是将其委托给更高级别（对调用者）。处理错误并返回它是不好的做法，好像调用者也这样做，错误可能会多次处理。

处理错误意味着检查它并根据它做出决定，这可能只是记录它，但也算作＆＃34;处理＆＃34;它

如果您选择不处理但将其委托给更高级别，那可能完全没问题，但不要只返回您获得的错误值，因为对于没有上下文的调用者来说这可能毫无意义。

注释错误

一种非常好的推荐授权方式是注释错误。这意味着您创建并返回 new 错误值，但旧的错误值也包含在返回的值中。包装器为包装错误提供上下文。

有一个用于注释错误的公共图书馆：github.com/pkg/errors;和它的godoc：errors

它基本上有两个功能：1 wrapping现有错误：

func Wrap(cause error, message string) error

一个extracting包装错误：

func Cause(err error) error

使用这些，这就是您的错误处理方式：

func (o *ObjectOne) CheckValue() error {
    if o.someValue == 0 {
        return errors.New("Object1 illegal state: value is 0")
    }
    return nil
}

第二级：

func (oT *ObjectTwoHigherLevel) CheckObjectOneIsReady() error {
    if err := oT.objectOne.CheckValue(); err != nil {
        return errors.Wrap(err, "Object2 illegal state: Object1 is invalid")
    }
    return nil
}

第三级：只调用二级检查：

func (oTh *ObjectThreeHiggerLevel) CheckObjectTwoIsReady() error {
    if err := oTh.ObjectTwoHigherLevel.CheckObjectOneIsReady(); err != nil {
        return errors.Wrap(err, "Object3 illegal state: Object2 is invalid")
    }
    return nil
}

请注意，由于CheckXX()方法无法处理错误，因此它们不会记录任何内容。他们正在委派注释错误。

如果使用ObjectThreeHiggerLevel的人决定处理错误：

o3 := &ObjectThreeHiggerLevel{}
if err := o3.CheckObjectTwoIsReady(); err != nil {
    fmt.Println(err)
}

将显示以下好的输出：

Object3 illegal state: Object2 is invalid: Object2 illegal state: Object1 is invalid: Object1 illegal state: value is 0

没有多个日志的污染，并且所有细节和上下文都被保留，因为我们使用errors.Wrap()生成了一个错误值，格式为string，以递归方式保留包装错误： 错误堆栈。

您可以在博文中了解有关此技术的更多信息：

Dave Cheney: Don’t just check errors, handle them gracefully

＆＃34;延伸＆＃34;错误

如果您喜欢简单的事情和/或您不想与外部资源库混淆，那么您就无法提取原始错误（确切的错误值，而不是错误 string ，你可以），然后你可以简单地用上下文扩展错误并返回这个新的扩展错误。

使用fmt.Errorf()可以最简单地扩展错误，这可以让您创建一个好的＆＃34;格式化的错误消息，它返回一个类型为error的值，因此您可以直接返回该值。

使用fmt.Errorf()，这就是您的错误处理方式：

func (o *ObjectOne) CheckValue() error { if o.someValue == 0 { return fmt.Errorf("Object1 illegal state: value is %d", o.someValue) } return nil }

第二级：

func (oT *ObjectTwoHigherLevel) CheckObjectOneIsReady() error { if err := oT.objectOne.CheckValue(); err != nil { return fmt.Errorf("Object2 illegal state: %v", err) } return nil }

第三级：只调用二级检查：

func (oTh *ObjectThreeHiggerLevel) CheckObjectTwoIsReady() error { if err := oTh.ObjectTwoHigherLevel.CheckObjectOneIsReady(); err != nil { return fmt.Errorf("Object3 illegal state: %v", err) } return nil }

以下错误消息将在ObjectThreeHiggerLevel显示，如果它决定＆＃34;处理＆＃34;它：

o3 := &ObjectThreeHiggerLevel{} if err := o3.CheckObjectTwoIsReady(); err != nil { fmt.Println(err) }

将显示以下好的输出：

Object3 illegal state: Object2 illegal state: Object1 illegal state: value is 0

请务必阅读博文：Error handling and Go

Answer 2

有各种库在Go错误中嵌入堆栈跟踪。只需使用其中一个创建错误，它就会冒出完整的堆栈上下文，您可以稍后检查或记录。

一个这样的图书馆：

https://github.com/go-errors/errors

还有一些我忘了。

从多个抽象级别处理错误的最佳实践

2 个答案:

注释错误

＆＃34;延伸＆＃34;错误