简单实现的java风格异常处理（try-catch-finally）。try catch不符合go错误处理风格，谨慎使用。
+ +函数签名: + +```go +func NewTryCatch(ctx context.Context) *TryCatch + +func (tc *TryCatch) Try(tryFunc func(ctx context.Context) error) *TryCatch + +func (tc *TryCatch) Catch(catchFunc func(ctx context.Context, err error)) *TryCatch + +func (tc *TryCatch) Finally(finallyFunc func(ctx context.Context)) *TryCatch + +func (tc *TryCatch) Do() +``` + +示例:[运行](todo) + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/xerror" +) + +func main() { + calledFinally := false + calledCatch := false + + tc := xerror.NewTryCatch(context.Background()) + + tc.Try(func(ctx context.Context) error { + return errors.New("error in try block") + }).Catch(func(ctx context.Context, err error) { + calledCatch = true + // Error in try block at /path/xxx.go:{line_number} - Cause: error message + // fmt.Println(err.Error()) + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + fmt.Println(calledCatch) + fmt.Println(calledFinally) + + // Output: + // true + // true +} +``` \ No newline at end of file diff --git a/docs/en/api/packages/xerror.md b/docs/en/api/packages/xerror.md index 07019d4..f4dc44f 100644 --- a/docs/en/api/packages/xerror.md +++ b/docs/en/api/packages/xerror.md @@ -35,6 +35,7 @@ import ( - [XError_Info](#XError_Info) - [XError_Error](#XError_Error) - [TryUnwrap](#TryUnwrap) +- [TryCatch](#TryCatch) @@ -166,12 +167,12 @@ import ( func main() { err1 := xerror.New("error").With("level", "high") - err2 := err1.Wrap(errors.New("invalid username")) + err2 := err1.Wrap(errors.New("invalid username")) - fmt.Println(err2.Error()) + fmt.Println(err2.Error()) - // Output: - // error: invalid username + // Output: + // error: invalid username } ``` @@ -487,3 +488,56 @@ func main() { // true } ``` + +### TryCatch + +Simple simulation of Java-style try-catch. It does not align with Go's error-handling philosophy. It is recommended to use it with caution.
+ +Signature: + +```go +func NewTryCatch(ctx context.Context) *TryCatch + +func (tc *TryCatch) Try(tryFunc func(ctx context.Context) error) *TryCatch + +func (tc *TryCatch) Catch(catchFunc func(ctx context.Context, err error)) *TryCatch + +func (tc *TryCatch) Finally(finallyFunc func(ctx context.Context)) *TryCatch + +func (tc *TryCatch) Do() +``` + +Example:[Run](todo) + +```go +package main + +import ( + "fmt" + "github.com/duke-git/lancet/v2/xerror" +) + +func main() { + calledFinally := false + calledCatch := false + + tc := xerror.NewTryCatch(context.Background()) + + tc.Try(func(ctx context.Context) error { + return errors.New("error message ") + }).Catch(func(ctx context.Context, err error) { + calledCatch = true + // Error in try block at /path/xxx.go:{line_number} - Cause: error message + // fmt.Println(err.Error()) + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + fmt.Println(calledCatch) + fmt.Println(calledFinally) + + // Output: + // true + // true +} +``` diff --git a/xerror/trycatch.go b/xerror/trycatch.go new file mode 100644 index 0000000..e688584 --- /dev/null +++ b/xerror/trycatch.go @@ -0,0 +1,100 @@ +package xerror + +import ( + "context" + "fmt" + "runtime" +) + +// TryCatch is a struct to handle try-catch-finally block. +// This implementation is merely a simulation of Java-style try-catch and does not align with Go's error-handling philosophy. It is recommended to use it with caution. +type TryCatch struct { + ctx context.Context + tryFunc func(ctx context.Context) error + catchFunc func(ctx context.Context, err error) + finallyFunc func(ctx context.Context) +} + +// NewTryCatch creates a new TryCatch instance. +func NewTryCatch(ctx context.Context) *TryCatch { + return &TryCatch{ + ctx: ctx, + } +} + +// Try sets the try function. +func (tc *TryCatch) Try(tryFunc func(ctx context.Context) error) *TryCatch { + tc.tryFunc = tryFunc + return tc +} + +// Catch sets the catch function. +func (tc *TryCatch) Catch(catchFunc func(ctx context.Context, err error)) *TryCatch { + tc.catchFunc = catchFunc + return tc +} + +// Finally sets the finally function. +func (tc *TryCatch) Finally(finallyFunc func(ctx context.Context)) *TryCatch { + tc.finallyFunc = finallyFunc + return tc +} + +// Do executes the try-catch-finally block. +func (tc *TryCatch) Do() { + defer func() { + if r := recover(); r != nil { + if tc.catchFunc != nil { + err := fmt.Errorf("panic: %v", r) + tc.catchFunc(tc.ctx, WrapCatchError(err, "Recovered from panic")) + } + } + + if tc.finallyFunc != nil { + tc.finallyFunc(tc.ctx) + } + }() + + if tc.ctx.Err() != nil { + if tc.catchFunc != nil { + tc.catchFunc(tc.ctx, WrapCatchError(tc.ctx.Err(), "Context cancelled or timed out")) + } + return + } + + if tc.tryFunc != nil { + if err := tc.tryFunc(tc.ctx); err != nil { + if tc.catchFunc != nil { + tc.catchFunc(tc.ctx, WrapCatchError(err, "Error in try block")) + } + } + } +} + +// CatchError is an error type to handle try-catch-finally block. +type CatchError struct { + Msg string + File string + Line int + Cause error +} + +// Error returns the error message. +func (e *CatchError) Error() string { + return fmt.Sprintf("%s at %s:%d - Cause: %v", e.Msg, e.File, e.Line, e.Cause) +} + +// WrapCatchError wraps an error with message, file, and line. +func WrapCatchError(err error, msg string) *CatchError { + _, file, line, ok := runtime.Caller(2) + if !ok { + file = "unknown" + line = 0 + } + return &CatchError{ + Msg: msg, + File: file, + Line: line, + Cause: err, + } +} diff --git a/xerror/trycatch_test.go b/xerror/trycatch_test.go new file mode 100644 index 0000000..08e7a78 --- /dev/null +++ b/xerror/trycatch_test.go @@ -0,0 +1,172 @@ +package xerror + +import ( + "context" + "errors" + "testing" + + "github.com/duke-git/lancet/v2/internal" +) + +func TestTryCatchSuccess(t *testing.T) { + t.Parallel() + + assert := internal.NewAssert(t, "TestTryCatchSuccess") + + counter := 0 + calledCatch := false + calledFinally := false + + tc := NewTryCatch(context.Background()) + + tc.Try(func(ctx context.Context) error { + counter++ + return nil + }).Catch(func(ctx context.Context, err error) { + calledCatch = true + t.Errorf("Catch should not be called") + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + assert.Equal(1, counter) + assert.Equal(false, calledCatch) + assert.Equal(true, calledFinally) +} + +func TestTryCatchError(t *testing.T) { + t.Parallel() + + assert := internal.NewAssert(t, "TestTryCatchError") + + var catchedError error + calledFinally := false + + tc := NewTryCatch(context.Background()) + + tc.Try(func(ctx context.Context) error { + return errors.New("error") + }).Catch(func(ctx context.Context, err error) { + catchedError = errors.New("catched error") + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + assert.Equal("catched error", catchedError.Error()) + assert.Equal(true, calledFinally) +} + +func TestTryCatchPanic(t *testing.T) { + t.Parallel() + + assert := internal.NewAssert(t, "TestTryCatchPanic") + + var catchedError error + calledFinally := false + + tc := NewTryCatch(context.Background()) + + tc.Try(func(ctx context.Context) error { + panic("panic info") + }).Catch(func(ctx context.Context, err error) { + catchedError = errors.New("catched error") + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + assert.Equal("catched error", catchedError.Error()) + assert.Equal(true, calledFinally) +} + +func TestTryCatchContextCancelled(t *testing.T) { + t.Parallel() + + assert := internal.NewAssert(t, "TestTryCatchContextCancelled") + + var catchedError error + calledFinally := false + + ctx, cancel := context.WithCancel(context.Background()) + cancel() + + tc := NewTryCatch(ctx) + + tc.Try(func(ctx context.Context) error { + return nil + }).Catch(func(ctx context.Context, err error) { + catchedError = errors.New("catched error") + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + assert.Equal("catched error", catchedError.Error()) + assert.Equal(true, calledFinally) +} + +func TestTryCatchContextTimeout(t *testing.T) { + t.Parallel() + + assert := internal.NewAssert(t, "TestTryCatchContextTimeout") + + var catchedError error + calledFinally := false + + ctx, cancel := context.WithTimeout(context.Background(), 0) + defer cancel() + + tc := NewTryCatch(ctx) + + tc.Try(func(ctx context.Context) error { + return nil + }).Catch(func(ctx context.Context, err error) { + catchedError = errors.New("catched error") + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + assert.Equal("catched error", catchedError.Error()) + assert.Equal(true, calledFinally) +} + +func TestTryCatchContextError(t *testing.T) { + t.Parallel() + + assert := internal.NewAssert(t, "TestTryCatchContextError") + + var catchedError error + calledFinally := false + + ctx, cancel := context.WithTimeout(context.Background(), 0) + defer cancel() + + tc := NewTryCatch(ctx) + + tc.Try(func(ctx context.Context) error { + return errors.New("error") + }).Catch(func(ctx context.Context, err error) { + catchedError = errors.New("catched error") + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + assert.Equal("catched error", catchedError.Error()) + assert.Equal(true, calledFinally) +} + +func TestTryCatchNoCatch(t *testing.T) { + t.Parallel() + + assert := internal.NewAssert(t, "TestTryCatchNoCatch") + + calledFinally := false + + tc := NewTryCatch(context.Background()) + + tc.Try(func(ctx context.Context) error { + return errors.New("error") + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + assert.Equal(true, calledFinally) +} diff --git a/xerror/xerror_example_test.go b/xerror/xerror_example_test.go index a936fe0..b03003f 100644 --- a/xerror/xerror_example_test.go +++ b/xerror/xerror_example_test.go @@ -1,6 +1,7 @@ package xerror import ( + "context" "errors" "fmt" "reflect" @@ -61,7 +62,7 @@ func ExampleXError_StackTrace() { // Output: // github.com/duke-git/lancet/v2/xerror.ExampleXError_StackTrace - // 52 + // 53 // true } @@ -154,3 +155,27 @@ func ExampleTryUnwrap() { // 42 // true } + +func ExampleTryCatch() { + calledFinally := false + calledCatch := false + + tc := NewTryCatch(context.Background()) + + tc.Try(func(ctx context.Context) error { + return errors.New("error message") + }).Catch(func(ctx context.Context, err error) { + calledCatch = true + // Error in try block at /path/xxx.go:174 - Cause: error message + // fmt.Println(err.Error()) + }).Finally(func(ctx context.Context) { + calledFinally = true + }).Do() + + fmt.Println(calledCatch) + fmt.Println(calledFinally) + + // Output: + // true + // true +}