用Go語言異常機制模擬TryCatch異常捕捉
有的同學看到Go和TryCatch一起出現，心裡可能會說，難道Go語言升級了，加入了try...catch語句。哈哈，其實Go語言從建立之初就沒打算加入try...catch語句，因為建立Go的那幫大爺認為try...catch挺煩人的，如果濫用，會造成程式混亂，所以就不打算加入try...catch（以後加不加入不好說）。
既然Go語言中並沒有try...catch語句，那麼為何文章標題說要使用TryCatch呢？其實Go語言中只是沒有try...catch語句，並不是沒有異常處理機制。Go語言中的異常處理機制就是著名的異常三劍客：panic、defer和recover。通過這3個傢伙，是完全可以模擬出try...catch語句效果的，對了，後面還應該有個finally。在正式模擬try...catch語句之前，先來回顧下Go語言中的異常處理機制是如何玩的。
Go語言中的異常處理機制
在前面提到，Go語言通過panic、defer和recover來處理異常的，那麼這3個東西是什麼呢？
不管是什麼異常處理機制，核心的原理都是一樣的，通常來講，一個完善的異常處理機制需要由下面3部分組成。
- 丟擲異常
- 處理異常的程式碼段
- 獲取異常資訊
下面先用Java的異常處理機制來說明這一點。
import java.io.IOException;
public class Main {
public static void main(String[] args) {
try
{
boolean ioException = false;
if (ioException) {
throw new IOException("ioexception");
} else {
throw new Exception("exception");
}
}
catch (IOException e) {
System.err.println(e);
}
catch (Exception e) {
System.out.println(e);
}
finally
{
System.out.println("finally");
}
}
}
上面的程式碼是標準的Java異常處理機制，try部分的throw用於丟擲異常，而catch部分的程式碼段用於處理特定的異常，通過catch子句的引數e可以獲取異常資訊。所以對於Java來說，上述的3個異常重要的組成部分都有。
對於Go語言來說，panic、defer和recover也分別對應了這3部分。其中panic是一個函式，用於丟擲異常，相當於Java中的throw函式。defer是一個關鍵字，用於修飾函式，用defer修飾的函式，在丟擲異常時會自動呼叫。recover是一個函式，用於獲取異常資訊，通常在用defer修飾的函式中使用。
下面是一段用Go語言處理異常的程式碼。
package main
import "fmt"
func main(){
// 處理異常的函式
defer func(){
fmt.Println("開始處理異常")
// 獲取異常資訊
if err:=recover();err!=nil{
// 輸出異常資訊
fmt.Println("error:",err)
}
fmt.Println("結束異常處理")
}()
exceptionFun()
}
func exceptionFun(){
fmt.Println("exceptionFun開始執行")
panic("異常資訊")
fmt.Println("exceptionFun執行結束")
}
實現Go版的TryCatch
現在已經瞭解了Go語言的異常處理機制，那麼接下來使用異常處理機制來模擬try...catch...finally語句。
現在來分析一下如果模擬。模擬的過程需要完成下面的工作。
- try、catch和finally這3部分都有各自的程式碼段，所以為了模擬try...catch...finally，需要用3個Go函式來分別模擬try、catch和finally部分的程式碼段。這3個Go函式是Try、Catch和Finally。
- 要確定這3個函式在什麼地方呼叫。Try是正常執行的程式碼，所以在要首先呼叫Try函式。而Catch函式只有在丟擲異常時呼叫，所以應該在用defer修飾的函式中呼叫，而且需要在Catch函式中獲取異常資訊，所以應該在使用cover函式獲取異常資訊後再呼叫Catch函式，通常會將異常資訊直接作為引數傳遞給Catch函式。不管是否丟擲異常，Finally函式都必須呼叫，所以應該用defer修飾Finally函式，而且是第1個用defer修飾的函式。這樣，在當前函式結束之前一定剛回呼叫Finally函式。
- 觸發異常，這就非常簡單了，直接用panic函式即可。
上面清楚地描述了用Go語言的異常處理機制模擬try...catch...finally語句的基本原理，下面給出完整的實現程式碼。
package main
import (
"fmt"
)
type ExceptionStruct struct {
Try func()
Catch func(Exception)
Finally func()
}
type Exception interface{}
func Throw(up Exception) {
panic(up)
}
func (this ExceptionStruct) Do() {
if this.Finally != nil {
defer this.Finally()
}
if this.Catch != nil {
defer func() {
if e := recover(); e != nil {
this.Catch(e)
}
}()
}
this.Try()
}
func main() {
fmt.Println("開始執行...")
ExceptionStruct{
Try: func() {
fmt.Println("try...")
Throw("發生了錯誤")
},
Catch: func(e Exception) {
fmt.Printf("exception %v\n", e)
},
Finally: func() {
fmt.Println("Finally...")
},
}.Do()
fmt.Println("結束執行")
}
上面的程式碼將Try、Catch、Finally函式都封裝在了ExceptionStruct結構體中。然後呼叫方式就與前面的描述的一致了。執行這段程式碼，會輸出如下圖的資訊。
增強版的TryCatch
到現在為止，其實已經完整地實現了try...catch...finally語句，但細心的同學會發現，這個實現有一點小問題。通常的try...catch...finally語句，try部分有且只有1個，finally部分是可選的，但最多隻能有1個，而catch部分也是可選的，可以有0到n個，也就是catch部分可以有任意多個。但前面的實現，Catch函式只能指定一個，如果要指定任意多個應該如何做呢？其實很簡單，用一個Catch函式集合儲存所有指定的Catch函式即可。不過需要快速定位某一個Catch函式。在Java中，是通過異常型別（如IOException、Exception等）定位特定的catch子句的，我們也可以模擬這一過程，通過特定的異常來定位與該異常對應的Catch函式，為了方便，可以用int型別的異常程式碼。那麼在呼叫Catch函式之前，就需要通過異常程式碼先定位到某一個Catch函式，然後再呼叫。下面就是完整的實現程式碼。
package main
import (
"log"
)
type Exception struct {
Id int // exception id
Msg string // exception msg
}
type TryStruct struct {
catches map[int]ExceptionHandler
try func()
}
func Try(tryHandler func()) *TryStruct {
tryStruct := TryStruct{
catches: make(map[int]ExceptionHandler),
try: tryHandler,
}
return &tryStruct
}
type ExceptionHandler func(Exception)
func (this *TryStruct) Catch(exceptionId int, catch func(Exception)) *TryStruct {
this.catches[exceptionId] = catch
return this
}
func (this *TryStruct) Finally(finally func()) {
defer func() {
if e := recover(); nil != e {
exception := e.(Exception)
if catch, ok := this.catches[exception.Id]; ok {
catch(exception)
}
finally()
}
}()
this.try()
}
func Throw(id int, msg string) Exception {
panic(Exception{id,msg})
}
func main() {
exception.Try(func() {
log.Println("try...")
// 指定了異常程式碼為2，錯誤資訊為error2
exception.Throw(2,"error2")
}).Catch(1, func(e exception.Exception) {
log.Println(e.Id,e.Msg)
}).Catch(2, func(e exception.Exception) {
log.Println(e.Id,e.Msg)
}).Finally(func() {
log.Println("finally")
})
}
執行結果如下圖所示。
這個實現與Java中的try...catch...finally的唯一區別就是必須要呼叫Finally函式，因為處理異常的程式碼都在Finally函式中。不過這並不影響使用，如果finally部分沒什麼需要處理的，那麼就設定一個空函式即可。
為了方便大家，我已經將該實現封裝成了函式庫，呼叫程式碼如下：
package main
import (
"exception"
"log"
)
func main() {
exception.Try(func() {
log.Println("try...")
exception.Throw(2,"error2")
}).Catch(1, func(e exception.Exception) {
log.Println(e.Id,e.Msg)
}).Catch(2, func(e exception.Exception) {
log.Println(e.Id,e.Msg)
}).Finally(func() {
log.Println("finally")
})
}
獲得本文原始碼，請關注”極客起源“或”歐瑞科技“公眾號，並輸入308178獲得原始碼。
&n