刚开始的时候理解如何使用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 teststart deferdefer 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: 0x20818c220Start TestTest7: PANIC Defered: Mimic PanicErr addr defer: 0x20818c2b0Main error: Mimic Error: 1
当测试方法给catchPanic这个defer方法传递err变量的时候，是按照传值引用的方式传递的。在Go语言中，所有的参数都是按照传值方式传递的。因此catchPanic这个defer方法有他独立的err变量的拷贝。任何的对catchPanic所拥有的err的拷贝的修改都只限于这个方法内部。
要修改由传值造成的代码的问题，就需要使用传递引用。
package mainimport ( "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 TestTestFinal: PANIC Defered: Mimic PanicErr addr defer: 0x2081c4020Main error: Mimic Panic
现在main方法打印出了panic的错误信息。
如果你要捕捉调用栈，需要引用“runtime”包。
使用以上方法就可以处理错误和各种panic的情况。很多情况下，这些情况只是需要记录日志或者在调用栈上处理掉。这样也会有效地降低error并保持代码整洁。然而，我学到的经验是最好只用上面的模式捕捉panic。日志什么的还是留给应用层面的逻辑处理吧。如果不这样，你可能会把错误两次写入日志。
希望这对你学习go语言有帮助！