golang简单而强大的错误处理插件库Falcon的使用

Golang简单而强大的错误处理插件库Falcon的使用

Falcon是一个用于Go语言的极简且高效的错误处理库，它提供了灵活的错误处理机制。

简单示例

下面是一个使用Falcon进行错误处理的基本示例：

// 创建一个新的错误处理器
errHandler := falcon.NewErrorHandler()

// 添加一个通用错误处理器
errHandler.AddHandler(func(err error, data ...interface{}) interface{} {
    fmt.Println("发生通用错误")
    return SomeData
})

// 添加一个特定错误类型的处理器
errHandler.AddHandler(func(err error, data ...interface{}) interface{} {
    fmt.Println("发生CustomErrorType类型的错误")
    return SomeData
}, CustomErrorType{})

// 检查错误并处理
SomeData := errHandler.Check(err, SomeRandomData1, SomeRandomData2)
// 在err之后传递的数据将被传递给处理器

完整示例Demo

下面是一个更完整的示例，展示了如何在真实场景中使用Falcon：

package main

import (
	"errors"
	"fmt"
	"github.com/SonicRoshan/falcon"
)

// 自定义错误类型
type MyCustomError struct {
	Message string
}

func (e MyCustomError) Error() string {
	return e.Message
}

func main() {
	// 创建错误处理器
	handler := falcon.NewErrorHandler()

	// 添加通用错误处理器
	handler.AddHandler(func(err error, data ...interface{}) interface{} {
		fmt.Printf("处理通用错误: %v\n", err)
		if len(data) > 0 {
			fmt.Printf("附带数据: %v\n", data[0])
		}
		return "默认返回值"
	})

	// 添加特定错误类型的处理器
	handler.AddHandler(func(err error, data ...interface{}) interface{} {
		fmt.Printf("处理MyCustomError错误: %v\n", err)
		if len(data) > 0 {
			fmt.Printf("附带数据: %v\n", data[0])
		}
		return "自定义错误返回值"
	}, MyCustomError{})

	// 模拟错误情况1 - 通用错误
	fmt.Println("测试1 - 通用错误:")
	result1 := handler.Check(errors.New("普通错误"), "附加数据1")
	fmt.Printf("结果: %v\n\n", result1)

	// 模拟错误情况2 - 自定义错误
	fmt.Println("测试2 - 自定义错误:")
	result2 := handler.Check(MyCustomError{"自定义错误"}, "附加数据2")
	fmt.Printf("结果: %v\n\n", result2)

	// 模拟无错误情况
	fmt.Println("测试3 - 无错误:")
	result3 := handler.Check(nil, "附加数据3")
	fmt.Printf("结果: %v\n", result3)
}

特性说明

  1. 多处理器支持：可以为不同类型的错误注册不同的处理器
  2. 数据传递：可以在检查错误时传递额外数据给处理器
  3. 返回值：每个处理器可以返回特定的值
  4. 类型匹配：可以精确匹配特定错误类型

Falcon通过这种简单而强大的方式，使得Go语言的错误处理更加灵活和可维护。


更多关于golang简单而强大的错误处理插件库Falcon的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang简单而强大的错误处理插件库Falcon的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Falcon - Golang 简单而强大的错误处理库

Falcon 是一个轻量级但功能强大的 Go 错误处理库，它提供了简洁的 API 和丰富的功能来改善 Go 的错误处理体验。

Falcon 的主要特性

  1. 错误包装：支持错误链式包装
  2. 错误分类：可定义错误类型和子类型
  3. 上下文信息：可附加键值对上下文信息
  4. 堆栈跟踪：自动捕获调用堆栈
  5. 错误转换：方便与其他错误类型互操作

安装

go get github.com/micro/go-micro/v2/errors

基本用法

创建新错误

package main

import (
	"fmt"
	"github.com/micro/go-micro/v2/errors"
)

func main() {
	// 创建一个基础错误
	err := errors.New("user.service", "user not found", 404)
	
	// 检查错误
	if err != nil {
		fmt.Printf("Error: %v\n", err)
	}
}

错误包装

func getUser(id string) error {
	// 模拟数据库操作
	_, err := db.GetUser(id)
	if err != nil {
		// 包装原始错误并添加更多上下文
		return errors.Wrap(err, "user.service", "failed to get user", 500)
	}
	return nil
}

错误分类

func processRequest(req *Request) error {
	if req.ID == "" {
		return errors.BadRequest("user.service", "missing user id")
	}
	
	if req.Age < 18 {
		return errors.Forbidden("user.service", "user underage")
	}
	
	return nil
}

高级用法

添加上下文信息

func login(username, password string) error {
	if username == "" || password == "" {
		err := errors.BadRequest("auth.service", "missing credentials")
		err = errors.WithContext(err, map[string]string{
			"username": username,
			"ip":       "192.168.1.1",
		})
		return err
	}
	
	// 登录逻辑...
	return nil
}

错误类型检查

func handleError(err error) {
	switch {
	case errors.IsBadRequest(err):
		fmt.Println("Bad request:", err)
	case errors.IsNotFound(err):
		fmt.Println("Not found:", err)
	case errors.IsInternalServerError(err):
		fmt.Println("Internal error:", err)
	default:
		fmt.Println("Unknown error:", err)
	}
}

提取错误详情

func logError(err error) {
	// 获取错误详情
	details := errors.FromError(err)
	
	log.Printf(`
		ID: %s
		Code: %d
		Detail: %s
		Status: %s
		Context: %v
	`,
		details.Id,
		details.Code,
		details.Detail,
		details.Status,
		details.Context,
	)
}

实际应用示例

package main

import (
	"fmt"
	"github.com/micro/go-micro/v2/errors"
	"net/http"
)

type User struct {
	ID   string
	Name string
	Age  int
}

var db = make(map[string]User)

func init() {
	db["1"] = User{ID: "1", Name: "Alice", Age: 25}
	db["2"] = User{ID: "2", Name: "Bob", Age: 30}
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	if id == "" {
		err := errors.BadRequest("user.api", "missing user id")
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	user, err := getUser(id)
	if err != nil {
		if errors.IsNotFound(err) {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
		return
	}

	fmt.Fprintf(w, "User: %+v", user)
}

func getUser(id string) (User, error) {
	user, exists := db[id]
	if !exists {
		return User{}, errors.NotFound("user.storage", "user not found")
	}
	return user, nil
}

func main() {
	http.HandleFunc("/user", getUserHandler)
	http.ListenAndServe(":8080", nil)
}

总结

Falcon 提供了比 Go 标准库 errors 更丰富的错误处理功能，主要优势包括：

  1. 结构化错误信息：可以附加错误码、类型、上下文等元数据
  2. 错误分类：内置常见 HTTP 错误类型
  3. 错误链：保留原始错误信息
  4. 易用性：API 设计简洁直观

对于需要更复杂错误处理的 Go 项目，Falcon 是一个值得考虑的选择。它特别适合微服务架构，其中错误需要在服务间传递并保持结构化信息。

回到顶部