用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結構體中。然後呼叫方式就與前面的描述的一致了。執行這段程式碼，會輸出如下圖的資訊。

　　image.png

　　增強版的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")

　　})

　　}

　　執行結果如下圖所示。

　　image.png

　　這個實現與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")

　　})

　　}

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/69976870/viewspace-2712238/，如需轉載，請註明出處，否則將追究法律責任。