开发者社区> ghost丶桃子> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

理解Defer、Panic和Recover

简介:
+关注继续查看

刚开始的时候理解如何使用Defer和Recover有一点怪异,尤其是使用了try/catch块的时候。有一种模式可以在Go中实现和try/catch语句块一样的效果。不过之前你需要先领会Defer、Panic和Recover的精髓。

首先你需要理解defer关键字的作用,请看如下的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main
 
import (
    "fmt"
)
 
func main() {
  test()
}
 
func minicError(key string) error {
  return fmt.Errorf("mimic error: %s", key)
}
 
func test() {
    fmt.Println("start test")
     
    err := minicError("1")
     
    defer func() {
        fmt.Println("start defer")
         
        if err != nil {
            fmt.Println("defer error:", err)
        }
    }()
     
    fmt.Println("end test")
}

mimicError方法是一个用来模拟错误的测试方法。这个方法按照Go语言的习惯返回错误。

在Go中错误类型被定义为一个借口:

1
2
3
type error interface {
    Error() string
}

如果你现在还理解不了Go的接口,下面的内容会有所帮助。任何实现了Error()方法的类型的变量都可以作为error类型的变量使用。MimicError方法使用errors.New(string)方法创建了一个error类型的变量。errors类型可以在errors包种找到。

测试方法会有如下的输出:

1
2
3
4
start test
end test
start defer
defer error: mimic error:   

仔细观察测试方法的输出你会发现这个方法是什么时候开始,什么时候结束的。在测试方法正常结束前,函数内部的defer方法被调用。两个有趣的事情会发生:首先,defer关键字修饰的方法会在测试方法结束后被调用。其次,由于Go支持使用闭包,err变量可以被内部函数访问,他的错误值“mimic error:1”输出到了stdout。

你可以任意时候在你的函数内部定义一个defer方法。如果那个defer方法需要用到状态,比如上面的代码中的err变量,那么这个变量必须在defer方法定义之前就已经存在。

下面对测试方法稍作修改:

1
2
3
4
5
start test
end test
start defer
defer error: mimic error: <strong>2
</strong>

这个输出和之前的输出几乎没有区别,只修改了一点。这一次的defer方法的输出是“mimic error: 2”。很明显,defer方法对err变量有一个引用。所以如果err变量的状态在defer方法调用前改变了,你就会看到修改之后的值。再次修改defer方法对err变量的引用。这次在测试方法和defer方法中使用err变量的内存地址。

从下面的输出中你会发现,defer方法拥有和测试方法一样的err变量地址。

1
2
3
4
5
6
start test
err address: <strong>0x20818a250</strong>
end test
start defer
err address in defer: <strong>0x20818a250</strong>
defer error: mimic error: 2

只要defer方法放在测试方法结束前,那么defer方法就一定会被执行。这很好,但是我想要的是每次测试方法在执行的时候defer方法就首先执行。这样就只能把这个方法放在调用方法的最前面。就如Occam所说:“如果你有两个竞争的理论有完全一样的预期,那么更简单的那个就是更好”。我需要的就是一个简单的不需要思考的可行的模式(pattern)。

唯一的问题是err变量需要定义在defer语句的前面。幸运的是Go允许返回的变量直接用于赋值。请看下面修改后的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main
 
import (
    "fmt"
)
 
func main() {
    if err := test(); err != nil {
        fmt.Printf("mimic error: %v\n", err)   
    }
}
 
func mimicError(key string) error {
    return fmt.Errorf("mimic error: %s", key)  
}
 
func test() (<strong>err error</strong>) {
    defer func() {
        fmt.Println("start defer")
         
        if <strong>err</strong> != nil {
            fmt.Println("defer error:", <strong>err</strong>)
        }
    }()
     
    fmt.Println("start test")
     
    <strong>err</strong> = mimicError("1")
     
    fmt.Println("end test")
     
    return <strong>err</strong>
}

测试方法定义了一个返回类型为error的变量。这样err变量立刻就存在了,并且你可以在defer语句中访问到。同时,test方法也遵循了Go语言的惯例--给调用者返回一个错误类型。

运行这段代码你会得到这样的输出:

1
2
3
4
5
start test
end test
start defer
defer error: mimic error: 1
mimic error: mimic error: 1

  现在就是时候讨论一下panic了。当Go的任何方法调用了panic的时候,程序的正常执行流程停止。调用panic的方法立刻停止并触发方法调用栈的panic链。所有在同一个调用栈的方法都会一个接一个的停止,就像多米诺骨牌一样。最终panic链会执行到栈顶,然后程序崩溃。一个好的地方是全部存在的defer方法都会在panic序列中执行,并且他们可以停止崩溃。

  下面的测试方法调用了内置的panic方法,并且从这一调用中恢复:

  仔细看一下defer方法:

1
2
3
4
5
6
7
    defer func() {
    fmt.Println("start panic defer")
     
    if r := recover(); r != nil {
        fmt.Println("defer panic:", r)
    }
}()

  defer方法调用了另一个内置的方法叫做recover。这个recover方法阻止了panic触发的奔溃链继续向上调用。recover方法只可以在defer方法中调用,这是因为panic链的方法中只有defer方法可以被执行。

  如果recover方法被调用,但是没有任何的panic发生,recover方法只会返回nil。如果有panic发生,那么panic就停止并且给panic的赋值会被返回。上次的代码没有调用MimicError方法,而是用内置的panic方法模拟了一个panic。运行代码后产生的输出:

start test
start defer
defer panic: Mimic Panic

defer方法可以捕获panic,把它打印在屏幕上并停止panic链的继续执行。同时需要注意的是“End Test”没有显示在屏幕上。测试方法在panic调用的时候就立刻停止了。

看起来不错,但是还有一个问题:我还是想显示“End Test”。defer很酷的地方在于你可以在方法里放多余一个的defer方法。

上面的方法可以修改如下:

1
2
3
4
5
6
start test
start defer
defer error: mimic error: 1
start panic defer
defer panic: Mimic Panic
mimic error: mimic error: 1

  现在两个defer方法都放在了测试方法的开始部分。第一个defer从panic中recover,之后打印错误。一个需要注意的地方Go语言会按照defer方法定义的反方向执行(先进先出)。

  运行之后的输出:

1
2
3
4
5
6
start test
start defer
defer error: mimic error: 1
start panic defer
defer panic: Mimic Panic
mimic error: mimic error: 1

  测试方法按照预期的调用了panic停止了测试方法本身的执行。之后处理错误的defer方法被首先执行。由于测试方法在panic之前调用了mimicError方法,所以error可以打印出来。之后recover方法被调用,panic链被中断。

  这段代码还是有一个问题。main方法根本不知道panic已经被处理了。main方法只知道发生了一个错误。就是mimicError方法模拟的错误。这可不行。我需要main方法知道引发了panic的错误。这个更是需要报出来的错误。

  我们需要在处理panic的defer方法中把panic的错误信息赋值给err变量。现在的输出:

1
2
3
4
5
6
7
start test
start defer
defer error: mimic error: 1
start panic defer
defer panic: Mimic Panic
<strong>mimic error: Mimic Panic
</strong>

这个时候main函数可以打印出引起panic的错误了。

  虽然看起来已经很完美了,但是这个代码不容易扩展。有两个内置的defer方法很酷但是不实用。我需要的是一个单个的,既可以除了错误又可以处理panic的方法。这里是提炼过后的全部代码,叫做_CatchPanic。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main
 
import (
    "fmt"
)
 
func main() {
    if err := test(); err != nil {
        fmt.Printf("Main error: %v\n", err)
    }
}
 
<strong>func catchPanic(err error, functionName string) {
    if r := recover(); r != nil {
        fmt.Printf("%s: PANIC Defered: %v\n", functionName, r)
         
        if err != nil {
            err = fmt.Errorf("%v", r)
        }
    }else if err != nil {
        fmt.Printf("%s: ERROR: %v\n", functionName, err)
    }
}</strong>
 
func mimicError(key string) error {
    return fmt.Errorf("Mimic Error: %s", key)  
}
 
func test() (err error) {
    <strong>defer catchPanic(err, "Test")</strong>
    fmt.Println("Start Test")
     
    err = mimicError("1")
     
    fmt.Println("End Test")
    return err
}

  新方法catchPanic把错误和panic都处理了。这里主要实用了外部定义defer方法体的方式代替了内部定义方法体。在开始测试以前,我们需要确定不会破坏已有的错误处理。运行代码后的输出:

1
2
3
Start Test
End Test
Main error: Mimic Error: 1

  现在我们测试一下panic

1
2
3
4
5
6
7
8
9
10
func test() (err error) {
    defer catchPanic(err, "Test")
    fmt.Println("Start Test")
     
    err = mimicError("1")
     
    panic("Mimic Panic")
    // fmt.Println("End Test")
    return err
}

  输出结果

1
2
3
Start Test
Test: PANIC Defered: Mimic Panic
Main error: Mimic Error: 1

  好吧,我们又有一个问题。main方法打印了err变量的信息,而不是panic的内容。那是什么东西出错了呢?

复制代码
func catchPanic(err error, functionName string) {
    if r := recover(); r != nil {
        fmt.Printf("%s: PANIC Defered: %v\n", functionName, r)
        
        if err != nil {
            err = fmt.Errorf("%v", r)
        }
    }else if err != nil {
        fmt.Printf("%s: ERROR: %v\n", functionName, err)
    }
}
复制代码

  因为defer调用的是外部定义的方法。所以没有了inline方法或者闭包的好处。修改代码,打印出测试方法的err地址和_CatchPanic这个defer方法。

复制代码
func _CatchPanic(err error, functionName string) {
    if r := recover(); r != nil {
        fmt.Printf("%s: PANIC Defered: %v\n", functionName, r)
        
        fmt.Println("Err addr defer:", &err)
        
        if err != nil {
            err = fmt.Errorf("%v", r)
        }
    }else if err != nil  {
        fmt.Printf("%s: ERROR: %v\n", functionName, err)
    }
}
复制代码

运行以后你会看到为什么main方法没有得到panic携带的错误:

Err addr:  0x20818c220
Start Test
Test7: PANIC Defered: Mimic Panic
Err addr defer: 0x20818c2b0
Main error: Mimic Error: 1

当测试方法给catchPanic这个defer方法传递err变量的时候,是按照传值引用的方式传递的。在Go语言中,所有的参数都是按照传值方式传递的。因此catchPanic这个defer方法有他独立的err变量的拷贝。任何的对catchPanic所拥有的err的拷贝的修改都只限于这个方法内部。

要修改由传值造成的代码的问题,就需要使用传递引用。

复制代码
package main

import (
    "fmt"
)

func main() {
    if err := testFinal(); err != nil {
        fmt.Printf("Main error: %v\n", err)    
    }
}

func _CatchPanic(err *error, functionName string) {
    if r := recover(); r != nil {
        fmt.Printf("%s: PANIC Defered: %v\n", functionName, r)
        
        fmt.Println("Err addr defer:", &err)
        
        if err != nil {
            *err = fmt.Errorf("%v", r)
        }
    }else if err != nil && *err != nil {
        fmt.Printf("%s: ERROR: %v\n", functionName, *err)
    }
}

func testFinal() (err error) {
    defer _CatchPanic(&err, "TestFinal")
    fmt.Printf("Start Test\n")
    
    err = minicError("1")
    
    panic("Mimic Panic")
}

func minicError(key string) error {
    return fmt.Errorf("Mimic Error: %s", key)    
}
复制代码

运行代码后输出:

Start Test
TestFinal: PANIC Defered: Mimic Panic
Err addr defer: 0x2081c4020
Main error: Mimic Panic

现在main方法打印出了panic的错误信息。

如果你要捕捉调用栈,需要引用“runtime”包。

使用以上方法就可以处理错误和各种panic的情况。很多情况下,这些情况只是需要记录日志或者在调用栈上处理掉。这样也会有效地降低error并保持代码整洁。然而,我学到的经验是最好只用上面的模式捕捉panic。日志什么的还是留给应用层面的逻辑处理吧。如果不这样,你可能会把错误两次写入日志。

希望这对你学习go语言有帮助!

 

 

 

  

 

 

 

 

  

 

 

 

  

 

欢迎加群互相学习,共同进步。QQ群:iOS: 58099570 | Android: 330987132 | Go:217696290 | Python:336880185 | 做人要厚道,转载请注明出处!http://www.cnblogs.com/sunshine-anycall/p/4746066.html

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
[20180306]关于DEFERRED ROLLBACK2.txt
[20180306]关于DEFERRED ROLLBACK2.txt --//上午测试DEFERRED ROLLBACK针对表空间offline才有效,我测试回滚一定会写到DEFERRED ROLLBACK段.
735 0
[20160819]什么是DEFERRED ROLLBACK.txt
[20160819]什么是DEFERRED ROLLBACK.txt A "Deferred Rollback" segment is created for a tablespace when a tablespace is taken offline.
803 0
[20180306]关于DEFERRED ROLLBACK.txt
[20180306]关于DEFERRED ROLLBACK.txt --//在oracle数据库存在一种特殊的ROLLBACK段,叫DEFERRED ROLLBACK.
990 0
restore和recover的区别
restore 是还原物理文件 recover 是用日志恢复到一致 用了RMAN备份后就必须要用restore还原,然后才用recover恢复 restore——还原,与backup相对,从备份读出恢复备份的数据。
522 0
浅谈defer、panic、recover 三者的用法
浅谈defer、panic、recover 三者的用法
0 0
Go-关键字defer、panic、recover详解
Go-关键字defer、panic、recover详解
0 0
Go 专栏|错误处理:defer,panic 和 recover
Go 专栏|错误处理:defer,panic 和 recover
0 0
recover database until cancel和 recover database区别
简单的说 recover database until cancel用于不完全恢复,可以一步一步的跳也就是一个一个归档的应用,也可以AUTO全部应用,当然也可以在恢复完某个archivelog后cancel退出,但是他不会恢复                                                 current logfile如果需要恢复current logfile需要自己指定。
757 0
文章
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载