2. Go 基础回顾：结构体与方法、接口与多态、错误处理机制、defer/panic/recover

在进入业务环境回放与权限验证实战之前，必须牢固掌握 Go 语言的四大核心机制。本章将围绕结构体与方法、接口与多态、错误处理、以及 defer/panic/recover 展开，这些是构建可靠权限系统的基石。

2.1 结构体与方法：数据建模的基石

Go 使用结构体（struct）来聚合不同类型的数据，并通过方法（method）为结构体绑定行为。这是实现权限模型中“用户”、“角色”、“资源”等实体的基础。

结构体定义与初始化

type User struct {
    ID       int
    Username string
    Roles    []string
}

// 初始化方式
u1 := User{ID: 1, Username: "admin", Roles: []string{"admin", "editor"}}
u2 := User{2, "guest", []string{"viewer"}} // 按字段顺序初始化（不推荐）

方法：值接收者 vs 指针接收者

接收者类型	语法	能否修改原结构体	适用场景
值接收者	func (u User) GetName() string	否（操作的是副本）	只读操作、小型结构体
指针接收者	func (u *User) AddRole(role string)	是（操作的是原对象）	修改状态、大型结构体、避免拷贝

func (u User) Display() string {
    return u.Username
}

func (u *User) GrantRole(role string) {
    u.Roles = append(u.Roles, role)
}

2.2 接口与多态：权限策略的解耦核心

接口定义行为契约，不关心具体实现。在权限验证中，接口让“验证策略”与“业务逻辑”完全解耦。

接口定义与隐式实现

type PermissionChecker interface {
    Check(userID int, resource string, action string) bool
}

// RBACChecker 隐式实现了 PermissionChecker 接口
type RBACChecker struct {
    // 内部维护角色-权限映射
}

func (r *RBACChecker) Check(userID int, resource string, action string) bool {
    // 具体 RBAC 验证逻辑
    return true
}

// ABACChecker 也隐式实现了同一个接口
type ABACChecker struct{}

func (a *ABACChecker) Check(userID int, resource string, action string) bool {
    // 具体 ABAC 属性验证逻辑
    return false
}

多态：同一接口，不同策略

func VerifyAccess(checker PermissionChecker, uid int, res string, act string) {
    if checker.Check(uid, res, act) {
        fmt.Println("✅ 权限验证通过")
    } else {
        fmt.Println("❌ 权限验证拒绝")
    }
}

// 运行时动态切换策略
var checker PermissionChecker
checker = &RBACChecker{}
VerifyAccess(checker, 1, "/api/data", "read")

checker = &ABACChecker{}
VerifyAccess(checker, 1, "/api/data", "read")

2.3 错误处理机制：防御性编程的防线

Go 没有异常抛出机制，错误通过返回值显式传递。这是构建高可靠权限系统的关键设计。

错误接口与自定义错误

type error interface {
    Error() string
}

// 自定义权限错误
type PermissionError struct {
    UserID   int
    Resource string
    Action   string
}

func (e *PermissionError) Error() string {
    return fmt.Sprintf("权限拒绝: 用户 %d 无法对资源 %s 执行 %s 操作", e.UserID, e.Resource, e.Action)
}

// 使用
func CheckPermission(uid int, res string, act string) error {
    if uid != 1 {
        return &PermissionError{UserID: uid, Resource: res, Action: act}
    }
    return nil
}

错误处理最佳实践

模式	代码示例	说明
哨兵错误	var ErrNotFound = errors.New("资源不存在")	使用 == 比较，适合固定错误
错误类型断言	var pe *PermissionError; errors.As(err, &pe)	提取自定义错误的详细信息
错误包装	fmt.Errorf("验证失败: %w", err)	保留原始错误链，便于调试

// 错误包装与解包示例
func ValidateToken(token string) error {
    return fmt.Errorf("token 过期: %w", ErrTokenExpired)
}

func main() {
    err := ValidateToken("abc")
    if errors.Is(err, ErrTokenExpired) {
        fmt.Println("检测到 token 过期，触发重新登录流程")
    }
}

2.4 defer/panic/recover：资源清理与异常兜底

这三个关键字构成了 Go 的异常控制与资源管理三角。在权限系统中，defer 用于释放锁、关闭连接；recover 用于防止验证逻辑中的 panic 导致整个服务崩溃。

defer：延迟执行，资源清理

type PermissionCache struct {
    mu sync.RWMutex
    // ...
}

func (c *PermissionCache) GetWithLock(key string) (interface{}, error) {
    c.mu.RLock()
    defer c.mu.RUnlock()  // 确保锁一定被释放

    // 复杂的查询逻辑...
    return c.data[key], nil
}

panic/recover：异常兜底

func SafePermissionCheck(checker PermissionChecker, uid int, res string, act string) (result bool, err error) {
    defer func() {
        if r := recover(); r != nil {
            // 将 panic 转为错误返回，防止服务崩溃
            err = fmt.Errorf("权限验证 panic: %v", r)
            result = false
        }
    }()

    // 如果 checker.Check 内部发生 panic，会被 recover 捕获
    return checker.Check(uid, res, act), nil
}

2.5 核心机制关系图

下图展示了 Go 四大机制在权限验证系统中的协作关系：

2.6 本章小结

• 结构体与方法：使用指针接收者修改状态，值接收者执行只读操作。
• 接口与多态：定义 PermissionChecker 接口，实现 RBAC/ABAC 策略的无缝切换。
• 错误处理：使用 errors.Is 和 errors.As 进行错误链分析，自定义错误携带上下文。
• defer/panic/recover：defer 确保资源释放，recover 作为权限验证中间件的最后防线。