3. RBAC 模型在 Go 中的实现：角色定义、权限分配与角色继承

基于角色的访问控制（RBAC）是权限合规中最广泛采用的模型。在 Go 中实现 RBAC 需要将 用户（User）、角色（Role）、权限（Permission） 以及 角色继承（Role Hierarchy） 映射为可组合的数据结构与校验逻辑。本节将给出可直接用于生产级项目的核心代码实现。

3.1 核心数据结构定义

RBAC 的底层依赖三个基础实体：用户、角色、权限。权限通常以 资源:操作 的字符串格式表示，例如 document:read、user:delete。

// Permission 表示一个具体的操作许可
type Permission struct {
    Resource string // 例如 "document"
    Action   string // 例如 "read", "write", "delete"
}

// Role 包含权限列表与父角色 ID（用于继承）
type Role struct {
    ID          string
    Name        string
    Permissions []Permission
    ParentID    string // 空字符串表示顶级角色
}

// User 关联多个角色
type User struct {
    ID      string
    Name    string
    RoleIDs []string
}

3.2 权限分配与校验引擎

权限校验的核心逻辑是：给定一个用户和一组资源操作，判断该用户是否拥有至少一个角色的权限覆盖该操作。角色继承要求在查找权限时递归合并父角色的权限集。

// RBACEngine 持有所有角色与用户的注册表
type RBACEngine struct {
    roles map[string]*Role   // roleID -> Role
    users map[string]*User   // userID -> User
}

// NewRBACEngine 初始化引擎
func NewRBACEngine() *RBACEngine {
    return &RBACEngine{
        roles: make(map[string]*Role),
        users: make(map[string]*User),
    }
}

// AddRole 注册角色
func (e *RBACEngine) AddRole(role *Role) {
    e.roles[role.ID] = role
}

// AddUser 注册用户
func (e *RBACEngine) AddUser(user *User) {
    e.users[user.ID] = user
}

// GetEffectivePermissions 递归获取角色及其所有父角色的权限并集
func (e *RBACEngine) GetEffectivePermissions(roleID string) []Permission {
    role, exists := e.roles[roleID]
    if !exists {
        return nil
    }
    // 收集当前角色权限
    permSet := make(map[string]Permission)
    for _, p := range role.Permissions {
        key := p.Resource + ":" + p.Action
        permSet[key] = p
    }
    // 递归合并父角色权限
    if role.ParentID != "" {
        parentPerms := e.GetEffectivePermissions(role.ParentID)
        for _, p := range parentPerms {
            key := p.Resource + ":" + p.Action
            permSet[key] = p
        }
    }
    result := make([]Permission, 0, len(permSet))
    for _, p := range permSet {
        result = append(result, p)
    }
    return result
}

// CheckPermission 检查用户是否拥有指定资源操作的权限
func (e *RBACEngine) CheckPermission(userID, resource, action string) bool {
    user, exists := e.users[userID]
    if !exists {
        return false
    }
    targetKey := resource + ":" + action
    for _, roleID := range user.RoleIDs {
        effectivePerms := e.GetEffectivePermissions(roleID)
        for _, p := range effectivePerms {
            key := p.Resource + ":" + p.Action
            if key == targetKey {
                return true
            }
        }
    }
    return false
}

3.3 角色继承的层次结构

角色继承允许子角色自动获得父角色的所有权限，减少重复分配。例如：管理员 继承 编辑者，编辑者继承 查看者。下图展示了三层继承关系与权限合并效果。

3.4 角色继承的代码实现细节

上述 GetEffectivePermissions 方法已经实现了递归合并。为了更清晰地展示继承链的构建，下面给出角色注册与继承关系的设置示例：

func main() {
    engine := NewRBACEngine()

    // 1. 定义角色（从父到子）
    viewer := &Role{
        ID:   "viewer",
        Name: "查看者",
        Permissions: []Permission{
            {Resource: "document", Action: "read"},
        },
        ParentID: "", // 顶级角色
    }

    editor := &Role{
        ID:   "editor",
        Name: "编辑者",
        Permissions: []Permission{
            {Resource: "document", Action: "write"},
        },
        ParentID: "viewer", // 继承查看者
    }

    admin := &Role{
        ID:   "admin",
        Name: "管理员",
        Permissions: []Permission{
            {Resource: "user", Action: "delete"},
        },
        ParentID: "editor", // 继承编辑者
    }

    engine.AddRole(viewer)
    engine.AddRole(editor)
    engine.AddRole(admin)

    // 2. 注册用户并分配角色
    userAlice := &User{
        ID:      "alice",
        Name:    "Alice",
        RoleIDs: []string{"admin"}, // 只分配管理员角色
    }
    engine.AddUser(userAlice)

    // 3. 权限校验
    canRead := engine.CheckPermission("alice", "document", "read")   // true（继承自 viewer）
    canWrite := engine.CheckPermission("alice", "document", "write") // true（继承自 editor）
    canDelete := engine.CheckPermission("alice", "user", "delete")   // true（自身权限）
    canManage := engine.CheckPermission("alice", "user", "create")   // false（未分配）

    fmt.Printf("Alice can read document: %v\n", canRead)   // true
    fmt.Printf("Alice can write document: %v\n", canWrite) // true
    fmt.Printf("Alice can delete user: %v\n", canDelete)   // true
    fmt.Printf("Alice can create user: %v\n", canManage)   // false
}

3.5 权限校验的完整流程

下图展示了从用户请求到权限裁决的完整数据流，包含角色继承的递归合并步骤。

3.6 生产环境增强建议

• 权限通配符支持：在 CheckPermission 中增加对 * 的匹配，例如 document:* 匹配所有 document 操作。
• 角色缓存失效：当角色权限或继承关系变更时，使用事件总线或版本号机制清除相关用户的权限缓存。
• 审计日志：每次权限校验失败应记录 userID、resource:action、timestamp，用于合规审计。
• 并发安全：RBACEngine 的读写操作应使用 sync.RWMutex 保护，或采用不可变快照模式。