Golang 中的 Recover 处理错误

于 2024-08-23 12:41:44 发布
阅读量521 收藏 9
点赞数 5
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82869454/article/details/141462913
版权

Golang 中的 recover 是一个鲜为人知但非常有趣和强大的功能。让我们看看它是如何工作的，以及在 Outreach.io 中如何利用它来处理 Kubernetes 中的错误。
Panic/Defer/Recover 基本上是 Golang 中对于其他编程语言中 throw/finally/catch 概念的替代品。它们有一些共同之处，但在一些重要细节上有所不同。

Defer

要充分理解 recover，我们首先需要谈论 defer 语句。defer 关键字前置于函数调用之前，使得该调用在当前函数返回之前执行。当我们在一个函数中使用多个 defer 语句时，它们按照后进先出的顺序执行，这使得创建清理逻辑变得非常容易，如下例所示：

package main

import (
    "context"
    "database/sql"
    "fmt"
)

func readRecords(ctx context.Context) error {
    db, err := sql.Open("sqlite3", "file:test.db?cache=shared&mode=memory")
    if err != nil {
        return err
    }
    defer db.Close() // 这个函数调用将在 readRecords 函数返回时第三个执行

    conn, err := db.Conn(ctx)
    if err != nil {
        return err
    }
    defer conn.Close() // 这个函数调用将在第二个执行

    rows, err := conn.QueryContext(ctx, "SELECT id FROM users")
    if err != nil {
        return err
    }
    defer rows.Close() // 这个函数调用将在第一个执行

    for rows.Next() {
        var id int64
        if err := rows.Scan(&id); err != nil {
            return err
        }
        fmt.Println("ID:", id)
    }
    return nil
}

func main() {
    readRecords(context.Background())
}

Panic

我们需要谈论的第二个主题是 panic，它是一个导致当前 goroutine 进入 panic 模式的函数。当前函数中的正常执行流程被停止，仅执行 defer 语句，然后对调用者函数执行相同的操作，因此一直冒泡到堆栈的顶部（main 函数），然后使程序崩溃。panic 可以直接调用（传递一个值作为参数），也可以由运行时错误引起。例如，由于空指针解引用：

package main

import "fmt"

func main() {
    var x *string
    fmt.Println(*x)
}
// panic: runtime error: invalid memory address or nil pointer dereference

Recover

recover 是一个内建函数，它使我们有可能在发生 panic 时重新获得控制。它仅在被调用的延迟函数中产生效果。在延迟函数之外调用时，它总是返回 nil。如果我们处于 panic 模式，调用 recover 会返回传递给 panic 函数的值。基本示例：

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered: %v\\n", r)
        }
    }()

    panic("spam, egg, sausage, and spam")
}
// Recovered: spam, egg, sausage, and spam

我们可以以同样的方式从运行时错误中恢复：

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered: %v\\n", r)
        }
    }()

    var x *string
    fmt.Println(*x)
}
// Recovered: runtime error: invalid memory address or nil pointer dereference

在这种情况下，recover 返回的值的类型是错误（更准确地说是 runtime.errorString）。
有一个限制：我们不能直接从 recover 块中返回值，因为在 recover 块中的 return 语句仅从延迟函数中返回，而不是从周围的函数中返回：

package main

import "fmt"

func foo() int {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered: %v\\n", r)
            return 1 // "too many return values" 因为我们仅从匿名函数返回
        }
    }()

    panic("spam, egg, sausage, and spam")
}

func main() {
    x := foo()
    fmt.Println(x)
}

如果我们想要更改函数返回的值，我们需要使用命名返回值：

package main

import "fmt"

func foo() (ret int) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered: %v\\n", r)
            ret = 1
        }
    }()

    panic("spam, egg, sausage, and spam")
}

func main() {
    x := foo()
    fmt.Println("value:", x)
}
// Recovered: spam, egg, sausage, and spam
// value: 1

一个更实际的例子，将 panic 转换为普通错误的转换可能如下所示：

package main

import (
    "fmt"

    "github.com/google/uuid"
)

// processInput 尝试将输入字符串转换为 uuid.UUID
// 它将 panic 转换为错误
func processInput(input string) (u uuid.UUID, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic: %v", r)
        }
    }()

    // 一些可能引发 panic 的逻辑（也可以是第三方逻辑），例如：
    u = uuid.MustParse(input)
    return u, nil
}

func main() {
    u, err := processInput("xxx")
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(u)
}
// panic: uuid: Parse(xxx): invalid UUID length: 3
// 00000000-0000-0000-0000-000000000000

现在让我们尝试一些稍微
复杂的东西。假设我们在 Kubernetes 中运行，并且我们想要编写一个通用的 recover 函数，处理所有未捕获的 panic 和运行时错误，并收集它们的堆栈跟踪，以便我们可以以结构化的方式记录它们（例如，以 JSON 格式）。

作者：爱发白日梦的后端
链接：https://juejin.cn/post/7307124993133297679
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/pkg/errors"
)

func foo() string {
    var s *string
    return *s
}

func handlePanic(r interface{}) error {
    var errWithStack error
    if err, ok := r.(error); ok {
        errWithStack = errors.WithStack(err)
    } else {
        errWithStack = errors.Errorf("%+v", r)
    }
    return errWithStack
}

func main() {
    logger := log.New(os.Stdout, "", 0)

    defer func() {
        if r := recover(); r != nil {
            err := handlePanic(r)
            logger.Println(
                "panic occurred",
                "msg", err.Error(),
                "stack", fmt.Sprintf("%+v", err),
            )
        }
    }()

    fmt.Println(foo())
}

// 输出：
// panic occurred msg: runtime error: invalid memory address or nil pointer dereference
// stack: runtime error: invalid memory address or nil pointer dereference
// main.handlePanic
//        /tmp/sandbox239055659/prog.go:19
// main.main.func1...

以上就是今天的内容！recover 函数并不是 Golang 开发者的日常必备工具，但正如你所看到的，它在某些情况下非常有用。

烦 啊
关注
golang异常处理panic recover error基本介绍
abcnull 的博客
06-21 739
文章目录背景panicpanic 函数声明panic 返回panic 引发recoverpanic & recover 使用例子recover 后程序正常执行 背景 在 go 中没有 try catch 的异常处理语句，但是有 defer，panic，recovor 来控制程序执行流程 当某函数 fun 出发 panic 异常，fun 后面代码停止运行，转而去运行 defer 代码（如果有 defer），再然后结束 fun 函数，并将当前处理权交给 fun 的调用函数，recover 之后函数正常往
Golang 错误处理
canduecho的专栏
06-16 1034
除了使用内置的error类型外，我们还可以自定义自己的错误类型，并编写相应的错误处理函数。这可以让我们更好地控制程序中的错误信息，并提供更好的用户体验。if err!= nil {return在这个例子中，我们定义了一个MyError结构体，它包含一个字符串类型的message字段，并实现了Error()方法。然后我们修改了divide函数，使其返回一个指向MyError结构体的指针。在main函数中，我们调用divide函数，并检查返回的error值是否为nil。
golang recover
weixin_42248522的博客
07-02 261
func main() { go func() { defer func() { if e := recover(); e != nil { log.Printf("recover: %v", e) } }() panic("煎鱼焦了") }() log.Println("Go 语言编程之旅：一起用 Go 做项目") } recover 要与 defer 联用，并且不跨协程（goroutine），才能够真正的拦截到 panic 事件 ...
golang之recover
all_about_WZY的博客
06-01 6112
这包括关闭文件、释放资源或执行其他清理操作，以确保程序的状态正确恢复，并且不会留下未处理的副作用。时，最好记录相关信息，并进行适当的报告。函数，我们可以实现程序的优雅恢复和错误处理，从而提高代码的可维护性和稳定性。中恢复，我们可以防止程序因错误而崩溃，而是采取适当的措施处理错误。函数时，需要谨慎使用，并遵循最佳实践，以确保代码的可读性和稳定性。是Go语言中的异常机制，当程序发生不可恢复的错误时，会引发一个。
golang中的recover
后台开发
01-11 2964
recover 崩溃了恢复 func testa() { fmt.Println("aaaa") } func testb() { defer func() { //可以打印错误信息 //recover() //fmt.Println(recover()) //没有错就不要打印 if err := recover(); err != nil { //产生了panic异常 fmt.Println(err)
Go语言recover
nexttrial的博客
09-09 3090
在 Go 语言 中，如果我们的函数或者程序出现了非常严重的问题，或者说我们的程序遇到了 panic 异常，此时我们的程序会终止运行。 但是，我们希望我们程序在发生错误后，我们能够做一些处理，保证程序可以继续运行，那么这时候，我们就需要使用异常恢复，即 recover。Golang 中的 recover 一般都是配套 defer 一起使用。 例： defer func() { if r := recover(); r != nil { fmt.Println("Recovere.
利用 Golang 中的 Recover 处理错误
ldxxxxll的博客
03-02 721
Golang 中的 recover 是一个鲜为人知但非常有趣和强大的功能。让我们看看它是如何工作的，以及在 Outreach.io 中如何利用它来处理 Kubernetes 中的错误。Panic/Defer/Recover 基本上是 Golang 中对于其他编程语言中 throw/finally/catch 概念的替代品。它们有一些共同之处，但在一些重要细节上有所不同。
Golang中的异常处理：Panic与Recover的对决
最新发布
08-06
Golang，通常被称为Go语言，是一种由谷歌开发的编程语言。它以简洁、高效、安全著称，并且非常适合构建大规模的分布式系统和微服务。Go语言的一些主要特点包括： 1. **简洁性**：Go语言的语法非常简单，易于学习。 ...
golang 多协程错误处理
xinxin100011的博客
09-06 779
Go多协程并发环境下的错误处理 两个协程A、B 如果A发生panic，B会挂掉！（程序整体会panic） A协程的panic，只有A可以recover func main() { go func() { for { fmt.Println("goroutine A is ok") time.Sleep(500 * time.Millisecond) } }() go func() { time.Sleep(1200 * time.Millisecond) panic(
go代码-golang代码异常处理
07-16
在Golang（Go语言）中，异常处理是一个关键的概念，它涉及到程序的错误处理和流程控制。Go语言并不像其他一些编程语言（如Java或Python）那样有显式的try-catch异常处理结构，而是采用了一种更为简洁和一致的错误...
golang 之recover() 使用笔记
xlh1121079556的博客
06-17 5416
作用：程序报panic时，会使整个程序挂掉，在实际工作中，报panic的地方可能会非常的多，一旦报panic会导致整个服务挂掉，是非常危险的。golang 引用recover()han
golang中recover和panic用法
weixin_33728268的博客
12-16 304
golang中没有try... catch...，所以当golang中遇到panic时，如果不进行recover，便会导致整个程序挂掉，具体例子如下： package main import ( "fmt" ) func main() { panic("fault") fmt.Println("panic") } 运行结果： panic: fault goro...
golang 在recover()中打印错误堆栈
Lucky小黄人的博客
12-07 1784
使用 debug.Stack() 获得错误堆栈内容 go func() { defer func() { if err := recover(); err != nil { s := string(debug.Stack()) fmt.Printf("err=%v, stack=%s\n", err, s) } }() }
golang recover异常处理
maybe的博客
09-28 938
go程序在运行过程中发生panic，会导致程序崩溃，我们可以通过recover来捕获panic，并进行异常处理。 panic会导致程序崩溃： func main(){ panic("process error") } goroutine里面的panic也会使程序崩溃： func main(){ go func(){ panic("goroutine panic") } time.Sleep(1*time.Second) fmt.Println("ok") } 在goroutine里使用de
go mysql recover_Golang Recover的一个小坑
weixin_42357981的博客
03-06 142
问题及场景业务当中有需要分发http.request.body的场景。比如微信回调消息只能指定一个地址，所以期望可以复制一份消息发给其他服务。由服务B和接收微信回调的服务A一起处理微信回调信息。本文将详细介绍golang复用http.request.body的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧解决思路最开始考虑的是直接转发http.request。使用Reve...
golang中的panic 和 recover
关于代码的那些事
10-13 985
什么是 panic？在 Go 语言中，程序中一般是使用错误来处理异常情况。对于程序中出现的大部分异常情况，错误就已经够用了。但在有些情况，当程序发生异常时，无法继续运行。在这种情况下，我们会使用 panic 来终止程序。当函数发生 panic 时，它会终止运行，在执行完所有的延迟函数后，程序控制返回到该函数的调用方。这样的过程会一直持续下去，直到当前的所有函数都返回退出，然后程序会打印出 panic 信息，接着打印出堆栈跟踪（Stack Trace），最后程序终止。
一道golang中关于recover的面试题
yqq1997的博客
07-24 316
recover使用
golang错误处理
11-09
olang错误处理机制是通过error类型来实现的。在Golang中，函数可以返回一个error类型的值，表示函数执行过程中是否出现了错误。如果函数返回的error值为nil，则表示函数执行成功；否则，表示函数执行失败，error值中包含了错误信息。开发者可以通过判断error值是否为nil来判断函数是否执行成功，如果不为nil，则可以根据error值中的错误信息进行相应的处理。 除了error类型，Golang还提供了panic和recover两个内置函数来处理错误。当程序出现无法处理的错误时，可以使用panic函数来抛出一个panic异常，程序会立即停止执行，并在调用栈中逐层查找defer函数，直到找到recover函数为止。recover函数可以捕获panic异常，并返回panic的值，程序会继续执行后续代码。 总的来说，Golang的错误处理机制相对简单，但是通过error类型、panic和recover函数的组合使用，可以实现灵活的错误处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值