Go实现try-catch-finally机制

前言

许多主流语言诸如：Java、Python都实现了try-catch-finally机制，而Go处理错误的方式却与前两种语言不同。关于Go处理异常的方式是好是坏仁者见仁智者见智，笔者还是更喜欢try-catch-fianlly的写法，这里便和大家分享一个Go实现的try-catch-finally机制。下面先贴部分代码的讲解，完整代码将在文章的末尾中给出。

Try-Catch-Finally

这里我们先来看一段代码：

type CatchHandler interface {
	Catch(e error, handler func(err error)) CatchHandler
	CatchAll(handler func(err error)) FinalHandler
	FinalHandler
}

type FinalHandler interface {
	Finally(handlers ...func())
}

func Try(f func()) CatchHandler {
	//返回一个实现CatchHandler接口的对象
	f() //调用f函数
	……
}

　　　　

CatchHandler接口需要实现三个方法，一个是Catch()，这个方法用于接收一个特定类型的error以及error的处理器，返回还是CatchHandler类型，CatchAll()接收一个error处理器用于处理所有的错误，并返回一个FinalHandler类型的接口，而FinalHandler接口只实现一个方法Finally()，这个方法可接收多个处理器，用于在执行完try-catch块之后执行。

这里有一些地方需要注意，按照我们的接口设计：Try函数返回CatchHandler接口对象，可以调用Catch()、CatchAll()、Finally()这三个方法，Catch()函数同样返回CatchHandler接口对象，而轮到CatchAll()的时候返回的FinallyHandler接口对象，只有调用一个Finally()。综上所述，未来我们的代码将实现成这样：

type Err1 struct {
	error
}
type Err2 struct {
	error
}

func main() {

	Try(func() {
		//业务代码
	}).Catch(Err1{}, func(err error) {
		//处理Err1类型的错误
	}).Catch(Err2{}, func(err error) {
		//处理Err2类型的错误
	}).CatchAll(func(err error) {
		//处理其他错误
	}).Finally(func() {
		//处理完try-catch块之后最终将会执行的的代码
	})

}

　　

上面的设计也符合传统try-catch-finally的写法。

现在，我们给出Try函数的实现：

func Try(f func()) CatchHandler {
	t := &catchHandler{}
	defer func() {
		defer func() { //<2>
			r := recover()
			if r != nil {
				t.err = r.(error)
			}
		}()
		f() //<1>
	}()
	return t
}

　　

上面的代码，在<1>处，我们将f()函数在一个defer块中调用。同时在<2>处，又声明了一个defer块，用于捕捉异常。<1>处的defer块会在Try()函数正常返回后（即return之后）调用，再执行返回后剩下的代码。然后我们返回了结构体catchHandler的指针，说明结构体catchHandler必须实现接口CatchHandler所需要的函数。CatchHandler除了自身的两个函数Catch()和CatchAll()之外，还继承了FinalHandler的Finally()函数。所以统共需要实现的三个函数至少有三个。

下面，我们来看下catchHandler结构体的实现：

type catchHandler struct {
	err      error
	hasCatch bool
}

//<1>RequireCatch函数有两个作用：一个是判断是否已捕捉异常，另一个是否发生了异常。如果返回false则代表没有异常，或异常已被捕捉。
func (t *catchHandler) RequireCatch() bool {
	if t.hasCatch { //<2>如果已经执行了catch块，就直接判断不执行
		return false
	}
	if t.err == nil { //<3>如果异常为空，则判断不执行
		return false
	}
	return true
}
func (t *catchHandler) Catch(e error, handler func(err error)) CatchHandler {
	if !t.RequireCatch() {
		return t
	}
	//<4>如果传入的error类型和发生异常的类型一致，则执行异常处理器，并将hasCatch修改为true代表已捕捉异常
	if reflect.TypeOf(e) == reflect.TypeOf(t.err) {
		handler(t.err)
		t.hasCatch = true
	}
	return t
}

func (t *catchHandler) CatchAll(handler func(err error)) FinalHandler {
	//<5>CatchAll()函数和Catch()函数都是返回同一个对象，但返回的接口类型却不一样，也就是CatchAll()之后只能调用Finally()
	if !t.RequireCatch() {
		return t
	}
	handler(t.err)
	t.hasCatch = true
	return t
}

func (t *catchHandler) Finally(handlers ...func()) {
	//<6>遍历处理器，并在Finally函数执行完毕之后执行
	for _, handler := range handlers {
		defer handler()
	}
	err := t.err
	//<7>如果异常不为空，且未捕捉异常，则抛出异常
	if err != nil && !t.hasCatch {
		panic(err)
	}
}

　　

catchHandler有两个字段：err和hasCatch，分别用于保存Try块中函数执行之后返回的异常，以及异常是否被捕捉。

• <1>RequireCatch函数有两个作用：一个是判断是否已捕捉异常，另一个是否发生了异常。如果返回false则代表没有异常，或异常已被捕捉。
• <2>如果已经执行了catch块，就直接判断不执行。
• <3>如果异常为空，则判断不执行。
• <4>如果传入的error类型和发生异常的类型一致，则执行异常处理器，并将hasCatch修改为true代表已捕捉异常。
• <5>CatchAll()函数和Catch()函数都是返回同一个对象，但返回的接口类型却不一样，也就是CatchAll()之后只能调用Finally()。
• <6>遍历处理器，并在Finally函数执行完毕之后执行。
• <7>如果异常不为空，且未捕捉异常，则抛出异常。

现在，让我们来执行下下面的main()函数：

type Err1 struct {
	error
}
type Err2 struct {
	error
}

func main() {

	//Try1
	Try(func() {
		fmt.Println("Try1 start")
		panic(Err1{error: errors.New("error1")})
	}).Catch(Err1{}, func(err error) {
		fmt.Println("Try1 Err1 Catch:", err.Error())
	}).Catch(Err2{}, func(err error) {
		fmt.Println("Try1 Err2 Catch:", err.Error())
	}).Finally(func() {
		fmt.Println("Try1 done")
	})

	//Try2
	Try(func() {
		fmt.Println("Try2 start")
		panic(Err2{error: errors.New("error2")})
	}).Catch(Err1{}, func(err error) {
		fmt.Println("Try2 Err1 Catch:", err.Error())
	}).CatchAll(func(err error) {
		fmt.Println("Try2 Catch All:", err.Error())
	}).Finally(func() {
		fmt.Println("Try2 done")
	})

	//Try3
	Try(func() {
		fmt.Println("Try3 start")
	}).Catch(Err1{}, func(err error) {
		fmt.Println("Try3 Err1 Catch:", err.Error())
	}).Finally(func() {
		fmt.Println("Try3 done")
	})

}

　　

运行结果：

[root@bogon ]# go run main.go
Try1 start
Try1 Err1 Catch: error1
Try1 done
Try2 start
Try2 Catch All: error2
Try2 done
Try3 start
Try3 done

　　

可以看到，这里确实实现了类似传统try-catch-finally机制。另外有两点需要注意：

1. 强烈建议这里基于Go实现的Try-Catch机制都调用一下CatchAll()，即有可能出现Catch()函数无法匹配到的异常。
2. 强烈建议这里的Try-Catch机制在不调用CatchAll()的情况下都要调用Finally()，即便你调用了Finally()也可以不塞任何处理函数进去。如果发生了异常，却没有捕捉到，传统的try-catch-finally机制会在finally执行完毕后抛出异常，如果没有finally块则直接抛出异常，而这里需要执行Finally()函数后才能抛出，在Finally()函数中我们判断有异常且异常未被捕捉，则会panic()出异常，如果发生异常未被捕捉，又没有调用Finally()，那异常只能消失在历史的洪流里啦！

最后，贴出完整代码：

package main

import (
	"reflect"
	"fmt"
	"errors"
)

type CatchHandler interface {
	Catch(e error, handler func(err error)) CatchHandler
	CatchAll(handler func(err error)) FinalHandler
	FinalHandler
}

type FinalHandler interface {
	Finally(handlers ...func())
}

func Try(f func()) CatchHandler {
	t := &catchHandler{}
	defer func() {
		defer func() {
			r := recover()
			if r != nil {
				t.err = r.(error)
			}
		}()
		f()
	}()
	return t
}

type catchHandler struct {
	err      error
	hasCatch bool
}

func (t *catchHandler) RequireCatch() bool { //<1>判断是否有必要执行catch块，true为需要执行，false为不执行
	if t.hasCatch { //<2>如果已经执行了catch块，就直接判断不执行
		return false
	}
	if t.err == nil { //<3>如果异常为空，则判断不执行
		return false
	}
	return true
}
func (t *catchHandler) Catch(e error, handler func(err error)) CatchHandler {
	if !t.RequireCatch() {
		return t
	}
	//<4>如果传入的error类型和发生异常的类型一致，则执行异常处理器，并将hasCatch修改为true代表已捕捉异常
	if reflect.TypeOf(e) == reflect.TypeOf(t.err) {
		handler(t.err)
		t.hasCatch = true
	}
	return t
}

func (t *catchHandler) CatchAll(handler func(err error)) FinalHandler {
	//<5>CatchAll()函数和Catch()函数都是返回同一个对象，但返回的接口类型却不一样，也就是CatchAll()之后只能调用Finally()
	if !t.RequireCatch() {
		return t
	}
	handler(t.err)
	t.hasCatch = true
	return t
}

func (t *catchHandler) Finally(handlers ...func()) {
	//<6>遍历处理器，并在Finally函数执行完毕之后执行
	for _, handler := range handlers {
		defer handler()
	}
	err := t.err
	//<7>如果异常不为空，且未捕捉异常，则抛出异常
	if err != nil && !t.hasCatch {
		panic(err)
	}
}

type Err1 struct {
	error
}
type Err2 struct {
	error
}

func main() {

	//Try1
	Try(func() {
		fmt.Println("Try1 start")
		panic(Err1{error: errors.New("error1")})
	}).Catch(Err1{}, func(err error) {
		fmt.Println("Try1 Err1 Catch:", err.Error())
	}).Catch(Err2{}, func(err error) {
		fmt.Println("Try1 Err2 Catch:", err.Error())
	}).Finally(func() {
		fmt.Println("Try1 done")
	})

	//Try2
	Try(func() {
		fmt.Println("Try2 start")
		panic(Err2{error: errors.New("error2")})
	}).Catch(Err1{}, func(err error) {
		fmt.Println("Try2 Err1 Catch:", err.Error())
	}).CatchAll(func(err error) {
		fmt.Println("Try2 Catch All:", err.Error())
	}).Finally(func() {
		fmt.Println("Try2 done")
	})

	//Try3
	Try(func() {
		fmt.Println("Try3 start")
	}).Catch(Err1{}, func(err error) {
		fmt.Println("Try3 Err1 Catch:", err.Error())
	}).Finally(func() {
		fmt.Println("Try3 done")
	})

}