2. 权限模型基础：用户-角色-权限三元关系、角色继承、职责分离约束、静态与动态分离

2.1 核心三元关系

RBAC（基于角色的访问控制）围绕三个核心实体：用户（User）、角色（Role）、权限（Permission）。用户与角色多对多关联，角色与权限多对多关联，用户通过角色间接获得权限，而非直接分配。这种解耦使权限管理灵活且可扩展。

三者的关系可用以下 SQL 建表语句表达（简化版）：

-- 用户表
CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(50) NOT NULL
);

-- 角色表
CREATE TABLE roles (
    id INT PRIMARY KEY,
    name VARCHAR(50) NOT NULL UNIQUE
);

-- 权限表
CREATE TABLE permissions (
    id INT PRIMARY KEY,
    name VARCHAR(50) NOT NULL UNIQUE,
    resource VARCHAR(100),
    action VARCHAR(50)
);

-- 用户-角色关联（多对多）
CREATE TABLE user_roles (
    user_id INT REFERENCES users(id),
    role_id INT REFERENCES roles(id),
    PRIMARY KEY (user_id, role_id)
);

-- 角色-权限关联（多对多）
CREATE TABLE role_permissions (
    role_id INT REFERENCES roles(id),
    permission_id INT REFERENCES permissions(id),
    PRIMARY KEY (role_id, permission_id)
);

2.2 角色继承（Role Hierarchy）

角色继承允许一个角色自动获得另一个角色的全部权限。通常采用单继承（树形）或多继承（有向无环图 DAG）。例如“超级管理员”继承“普通管理员”，后者又继承“用户”。继承关系可加速权限授予，但需注意循环与冲突。

数据库实现常见两种方式：

• 邻接表：在角色表添加 parent_role_id 字段（不推荐，查询复杂）。
• 闭包表：新建角色继承关系表，存储所有祖先-后代对（推荐，查询高效）。

-- 闭包表实现角色继承
CREATE TABLE role_hierarchy (
    ancestor_id INT REFERENCES roles(id),
    descendant_id INT REFERENCES roles(id),
    depth INT,          -- 0 表示自引用，1 表示直接父级，等等
    PRIMARY KEY (ancestor_id, descendant_id)
);

-- 示例：admin 继承 user
INSERT INTO role_hierarchy VALUES (1, 1, 0);  -- 自引用
INSERT INTO role_hierarchy VALUES (2, 2, 0);  -- user 角色
INSERT INTO role_hierarchy VALUES (1, 2, 1);  -- admin 继承 user

2.3 职责分离约束（Separation of Duty, SoD）

职责分离用于防止利益冲突或权限滥用，分为静态职责分离（SSD）和动态职责分离（DSD）。

2.3.1 静态职责分离 (SSD)

在用户注册或角色分配阶段强制约束：同一个用户不能同时拥有一组冲突角色。例如“出纳员”和“审核员”互斥，一个用户不能同时被授予这两个角色。SSD 通常在数据库层通过互斥集表实现。

-- 互斥角色集表（SSD）
CREATE TABLE ssd_constraints (
    set_id INT,                    -- 冲突集编号
    role_id INT REFERENCES roles(id),
    PRIMARY KEY (set_id, role_id)
);

-- 示例：出纳员（role_id=3）与审核员（role_id=4）互斥
INSERT INTO ssd_constraints VALUES (1, 3);
INSERT INTO ssd_constraints VALUES (1, 4);

-- 分配角色时的校验逻辑（伪代码）
-- 若用户试图添加 role_id=4，且用户已有 role_id=3，且两者属于同一 set_id，则拒绝操作。

2.3.2 动态职责分离 (DSD)

在用户登录并建立会话（Session）时约束：用户在同一会话中不能同时激活一组冲突角色，但允许在不同会话中拥有这些角色。DSD 需要运行时缓存判断。

// 示例：动态职责分离检查（Java 伪代码）
class Session {
    Set<Role> activeRoles;
    
    boolean activateRole(Role newRole) {
        // 检查 DSD 约束，例如 role “操作员”与“监控员”不能在同一个会话激活
        for (Role existing : activeRoles) {
            if (dsdConstraintExists(existing, newRole)) {
                return false; // 拒绝激活
            }
        }
        activeRoles.add(newRole);
        return true;
    }
}

2.4 三元关系与约束的SVG结构图

2.5 实现流程与API示例

1. 定义角色与权限：在数据库或配置文件中创建角色和权限条目。
2. 建立关联：为角色分配权限（role_permissions），为用户分配角色（user_roles）。
3. 配置继承：插入角色继承关系（闭包表）。
4. 设置SSD/DSD约束：定义互斥集，并在分配或激活时触发检查。
5. 权限校验：用户请求资源时，计算用户拥有的所有角色（含继承）的权限并集。

以下是基于 REST API 的典型查询与分配操作（JSON 格式示例）：

// 1. 创建角色
POST /api/roles
{
  "name": "管理员",
  "parent_role_id": null
}

// 响应
{
  "id": 1,
  "name": "管理员"
}

// 2. 为用户分配角色
POST /api/users/123/roles
{
  "role_id": 1
}

// 3. 查询用户权限（含继承）
GET /api/users/123/permissions

// 响应
{
  "permissions": [
    {"resource": "/orders", "action": "POST"},
    {"resource": "/users", "action": "DELETE"},
    {"resource": "/logs", "action": "GET"}
  ]
}

2.6 调试与常见错误

// 调试命令示例（Python+SQLite）
import sqlite3

conn = sqlite3.connect('rbac.db')
cur = conn.cursor()

# 查看用户的角色及父角色
cur.execute("""
    SELECT DISTINCT r.name
    FROM user_roles ur
    JOIN roles r ON ur.role_id = r.id
    WHERE ur.user_id = 123
    UNION
    SELECT r2.name
    FROM role_hierarchy rh
    JOIN roles r2 ON rh.ancestor_id = r2.id
    JOIN user_roles ur2 ON rh.descendant_id = ur2.role_id
    WHERE ur2.user_id = 123 AND rh.depth > 0
""")
print("用户有效角色：", cur.fetchall())

2.7 性能与稳定性优化

• 缓存权限结果：为每个用户缓存计算后的权限集合（如 Redis），更新角色/权限时清除缓存。
• 索引：为 user_roles(role_id, user_id)、role_permissions(role_id, permission_id)、role_hierarchy(descendant_id) 创建复合索引。
• 闭包表查询优化：权限校验时使用 EXISTS 子查询结合闭包表，避免全表扫描。
• 约束检查预加载：启动时加载所有 SSD/DSD 冲突集到内存字典，避免每次分配都查表。