理解Defer、Panic和Recover

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

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

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中错误类型被定义为一个借口：

type error interface {
	Error() string
}

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

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

start test
end test
start defer
defer error: mimic error: 　　

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

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

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

start test
end test
start defer
defer error: mimic error: 2

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

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

start test
err address: 0x20818a250
end test
start defer
err address in defer: 0x20818a250
defer error: mimic error: 2

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

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

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() (err error) {
	defer func() {
		fmt.Println("start defer")

		if err != nil {
			fmt.Println("defer error:", err)
		}
	}()

	fmt.Println("start test")

	err = mimicError("1")

	fmt.Println("end test")

	return err
}

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

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

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方法：

        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方法。

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

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方法定义的反方向执行（先进先出）。

　　运行之后的输出：

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变量。现在的输出：

start test
start defer
defer error: mimic error: 1
start panic defer
defer panic: Mimic Panic
mimic error: Mimic Panic

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

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

package main

import (
	"fmt"
)

func main() {
	if err := test(); 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)

		if err != nil {
			err = fmt.Errorf("%v", r)
		}
	}else if err != nil {
		fmt.Printf("%s: ERROR: %v\n", functionName, err)
	}
}

func mimicError(key string) error {
	return fmt.Errorf("Mimic Error: %s", key)
}

func test() (err error) {
	defer catchPanic(err, "Test")
	fmt.Println("Start Test")

	err = mimicError("1")

	fmt.Println("End Test")
	return err
}

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

Start Test
End Test
Main error: Mimic Error: 1

　　现在我们测试一下panic：

func test() (err error) {
	defer catchPanic(err, "Test")
	fmt.Println("Start Test")

	err = mimicError("1")

	panic("Mimic Panic")
	// fmt.Println("End Test")
	return err
}

　　输出结果

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语言有帮助！