大家来谈谈程序中用户权限设计

权限问题好象很少有人关注，其实它很重要，我转一篇吧。
当 前MIS 的 开 发 多 采 用C/S 模 式， 即 数 据 处 理（ 定 义、 查 询 和 更 新） 由 数 据 库 服 务 器 集 中 管 理 而 系 统 应 用 则 由 客 户 机 程 序 实 现。 在 这 种 模 式 下， 业 务 处 理 逻 辑 存 放 于 工 作 站 的 客 户 机 程 序 中， 由 于 不 同 身 份 的 用 户 其 业 务 处 理 逻 辑 不 同， 如 果 单 独 为 每 类 用 户 开 发 与 之 工 作 相 对 应 的 应 用 程 序， 无 疑 会 将 系 统 开 发 工 作 复 杂 化 而 延 长 工 程 周 期， 也 不 利 于 以 后 的 维 护 工 作。 针 对 这 种 情 况， 在 实 际 开 发 过 程 中， 一 个 业 务 部 门 的 客 户 机 程 序 通 常 被 设 计 成 通 用 型 的（ 即 将 所 有 功 能 集 中 于 一 身）， 并 将 各 项 功 能 的 选 择 权 限 化， 通 过 权 限 控 制 为 不 同 身 份 的 用 户 赋 予 与 之 身 份 对 应 的 各 项 操 作， 屏 蔽 不 能 执 行 的 操 作 调 用， 以 此 实 现 分 工 负 责。 这 种 实 现 方 式 降 低 了 系 统 开 发 的 复 杂 度， 缩 短 了 开 发 周 期， 同 时 由 于 代 码 相 对 集 中 而 使 维 护 工 作 难 度 降 低， 所 以 成 为 当 前 开 发MIS 常 用 的 一 种 实 现 方 式。

---- 采 用 这 种 通 用 模 式 设 计 程 序， 权 限 控 制 就 成 为 系 统 的 运 行 管 理 核 心， 尤 其 在 维 护 系 统 安 全 方 面 起 着 重 要 的 作 用， 因 此 权 限 控 制 模 块 的 设 计 与 实 现 就 显 得 极 为 重 要。 权 限 控 制 模 块 的 设 计 应 分 为3 个 方 面： 权 限 列 表 结 构 设 计、 权 限 管 理 机 制 设 计 和 运 行 控 制 机 制 设 计。

一、 权 限 列 表 结 构 设 计
---- 权 限 列 表 结 构 设 计 属 于 系 统 设 计 数 据 结 构 设 计 层 次， 是 权 限 控 制 机 制 代 码 设 计 的 基 础。
---- 其 设 计 可 采 用 权 限 字 段 化 和 权 限 数 值 化 两 种 模 式。

---- 1. 权 限 字 段 化

---- 即 将 各 权 限 定 义 为 权 限 列 表 的 属 性， 定 义 如 下：

Table User_Permission(
UserID char(n), // 用 户 代 码
Permission1 logical // 权 限1
Permission2 logical // 权 限2
.
PermissionN logical // 权 限N)
---- 采 用 这 种 模 式， 用 户 的 权 限 定 义 就 由 权 限 列 表 中 一 条 元 组 全 部 体 现 出 来。 是 否 拥 有 某 权 限 则 通 过 元 组 中 该 权 限 属 性 的 值（True、False 或 其 他 能 体 现" 开 关" 性 质 的 值） 来 体 现。
---- 如 一 个 会 计 应 用 系 统 的 权 限 列 表 定 义 如 下：

Table User_Permission(
UserID char(n), // 用 户 代 码
Zhizheng logical // 制 证
Shenhe logical // 审 核
Jizhang logical // 记 账
Zhuguan logical // 主 管）
---- 如 果 用 户Jason 具 有 审 核 权 和 主 管 权， 则 其 权 限 在 权 限 列 表 被 表 示 如 下 表。
---- 这 种 模 式 的 优 点 是： 数 据 结 构 简 明， 对 权 限 的 控 制 比 较 简 单， 因 为 对 权 限 的 操 作（ 查 询、 更 改 和 撤 消） 都 集 中 在 一 条 元 组 的 不 同 属 性 上。 但 这 种 模 式 也 有 其 不 尽 人 意 之 处， 即 权 限 列 表 结 构 定 义 是 基 于 权 限 划 分 的， 是 一 种 动 态 的 表 达 形 式， 一 旦 权 限 划 分 出 现 变 动， 则 需 更 改 数 据 结 构 和 权 限 控 制 代 码， 因 此 这 种 模 式 适 用 于 权 限 划 分 稳 定 的 应 用 系 统( 如 会 计 系 统)。

---- 2. 权 限 数 值 化

---- 结 构 定 义 如 下：

---- Table User_Permission(

---- UserID String, // 用 户 代 码

---- Permission String// 权 限 名 称)

---- 在 这 种 模 式 下， 用 户 的 每 项 权 限 由 一 条 元 组 表 示， 是 一 对 一 的 关 系。 对 用 户 的 赋 予 与 撤 消 通 过 权 限 列 表 记 录 的 添 加 与 删 除 来 实 现。 如 上 例， 用 户Jason 的 权 限 在 此 模 式 下 可 表 示 如 下:

---- UserID

---- QX

---- Jason

---- Shenhe

---- Jason

---- Zhuguan

---- 这 种 模 式 其 优 点 是 通 用 性 强， 因 为 其 结 构 定 义 不 基 于 权 限 划 分， 当 权 限 划 分 发 生 变 化 时， 只 表 现 为 列 表 元 组 数 目 的 增 减， 权 限 管 理 和 运 行 控 制 的 代 码 无 须 更 改; 其 缺 点 是 操 作 代 码 较 为 复 杂， 需 要 处 理 的 数 据 量 较 大（ 一 个 用 户 的 权 限 就 是 一 个 记 录 集 合）， 当 然 这 与 其 通 用 性 相 比 是 微 不 足 道 的。

二、 权 限 管 理 机 制 设 计
---- 对 用 户 权 限 的 管 理 包 括 授 权（Grant） 和 撤 消(Revoke) 两 类 操 作。
---- 1. 授 权 操 作

---- 授 权 操 作 可 用 如 下 函 数 表 示（ 伪 代 码）：

Function Grant
(UserID:String;Qx:String):Boolean;
Begin
If having(UserID:String;Qx:String)
then return True
// 若已拥有该权限则返回成功信息
ElseIf Add(UserID:String;Qx:String) then return True
//否则若为该用户增加指定权限成功则返回成功信息
Else return False;
//否则返回失败信息
End;

---- 2. 撤 消 操 作
Function Revoke(UserID:
String;Qx:String):Boolean;
Begin
If not having(UserID:String;Qx:String)
then return True
//若未拥有该权限则返回成功信息
ElseIf Withdraw(UserID:String;Qx:String) then return True
//否则若撤消该用户指定权
Else return False;
//限成功则返回成功信息，否则返回失败信息
End;
---- 上 述 两 函 数 仅 描 述 了 工 作 原 理， 具 体 实 现 代 码 应 根 据 所 选 择 的 权 限 列 表 模 式 编 写。
三、 运 行 控 制 机 制 设 计
---- 运 行 控 制 机 制 是 指 根 据 用 户 权 限 将 其 操 作 限 制 在 权 限 允 许 的 范 围 内， 运 行 控 制 机 制 的 设 计 是 业 务 分 工 权 限 化 管 理 的 具 体 实 施 阶 段。 运 行 控 制 机 制 的 基 本 工 作 原 理 如 下( 伪 代 码)：
Procedure Runtime_Console；
Var UserID,Fun,Qx:String;
Begin
UserID:=Get_CurrentUser;//取得当前用户标识
Fun:=Get_Request_Function;//捕获当前操作名称
Qx:=getQx(Fun);//取得该操作对应的权限名称
If Having(UserID,Qx ) then Call_Function(Fun)
//若该用户拥有该操作权限则执行该操作
Else Refuse(Fun);//否则拒绝执行该操作
End;
---- 由 于 设 计 风 格 的 不 同， 运 行 控 制 机 制 的 具 体 实 现 方 式 亦 有 所 不 同。 笔 者 将 其 划 分 为3 种 类 型。
---- 1. 隐 藏 功 能 型（Invisible Style）

---- 该 类 型 控 制 方 式 是 只 对 用 户 提 供 其 权 限 允 许 的 操 作， 隐 藏 无 权 执 行 的 操 作 调 用（ 选 单 项 或 命 令 按 钮）。 这 种 控 制 方 式 的 优 点 是 用 户 操 作 界 面 与 其 业 务 分 工 相 对 应， 无 多 余 的 业 务 内 容 影 响 其 操 作 视 野， 故 实 用 性 强， 而 且 非 授 权 操 作 的 不 可 见 性 在 一 定 程 度 上 提 高 了 系 统 的 安 全 性。

---- 实 现 过 程： 当 用 户 登 录 成 功 后， 在 主 操 作 界 面（ 功 能 选 择 界 面） 激 活 之 际（OnActivate） 即 进 行 如 下 操 作：

---- (1) 隐 藏 所 有 操 作 调 用（ 选 单 项 及 按 钮）；

---- (2) 读 取 其 权 限 数 据， 并 据 此 将 赋 予 权 限 对 应 的 操 作 调 用 显 示 出 来。

---- 操 作 伪 代 码 如 下：

Procedure Runtime_Console;
Var Fun,Qx,UserID:DataType
Begin
Invisible_all_function_caller;
//隐藏所有功能调用
UserID:=Get_CurrentUser;
//取得当前用户标识
While not EOF(Qx set of UserID ) do Begin
//进行功能调用显示
Qx:=UserID.Qx.Value;
//读取一项权限
Fun:=Get_Function(Qx);
//取得该权限对应的操作名称
Case Fun Of
//根据操作名称显示其调用对象
（选单项或按钮）
Fun1:SetVisible(Fun1_Caller);
Fun2:SetVisible(Fun2_Caller);
.
.
FunN:SetVisible(FunN_Caller);
End;
UserID.Qx.next;//权限集合指针下移
End;
End;
---- 2. 禁 止 功 能 型（Disable Style）
---- 该 类 型 控 制 方 式 是 只 激 活（Enable） 用 户 权 限 对 应 的 操 作 调 用（ 选 单 项 或 命 令 按 钮）， 禁 止（Disable） 无 权 执 行 的 操 作 调 用（ 选 单 项 及 命 令 按 钮）。 这 种 控 制 方 式 的 优 点 是 能 够 全 面 体 现 系 统 所 具 有 的 功 能， 使 用 户 对 系 统 所 能 进 行 的 操 作 有 了 全 面 的 了 解， 在 主 观 上 给 用 户 以 系 统 的 设 计 完 全 符 合 其 要 求 的 满 足 感； 但 其 缺 点 是 操 作 界 面 与 用 户 业 务 分 工 不 一 致， 操 作 界 面 略 显 混 乱， 更 重 要 的 是 系 统 功 能 的 全 部 暴 露 容 易 给 不 法 分 子 指 定 攻 击 目 标， 威 胁 系 统 的 安 全 运 行。 实 现 过 程： 当 用 户 登 录 成 功 后， 在 主 操 作 界 面（ 功 能 选 择 界 面） 激 活 之 际（OnActivate） 即 进 行 如 下 操 作：

---- (1) 禁 止 所 有 操 作 调 用（ 选 单 项 及 按 钮）；

---- (2) 读 取 其 权 限 数 据， 并 据 此 将 赋 予 权 限 对 应 的 操 作 调 用 激 活。 操 作 伪 代 码 如 下：

Procedure Runtime_Console;
Var Fun,Qx,UserID:DataType
Begin
Disable_all_function_caller;
//禁止所有功能调用
UserID:=Get_CurrentUser;
//取得当前用户标识
While not EOF(Qx set of UserID ) do Begin
//进行功能调用激活
Qx:=UserID.Qx.Value;
//读取一项权限
Fun:=Get_Function(Qx);
//取得该权限对应的操作名称
Case Fun Of
//根据操作名称激活调用对象
Fun1:SetEnable(Fun1_Caller);
Fun2:SetEnable(Fun2_Caller);
.
.
FunN:SetEnable(FunN_Caller);
End;
UserID.Qx.next;
//权限集合指针下移
End;
End;
---- 可 以 看 出， 以 上 两 种 控 制 方 式 在 实 现 上 差 别 很 小， 而 且 有 一 个 共 同 点， 即 控 制 发 生 在 主 操 作 界 面 的 激 活 期。 选 择 这 一 控 制 时 点， 是 为 了 保 证 在 用 户 工 作 过 程 中 其 权 限 发 生 变 化 时 对 该 用 户 的 控 制 会 立 即 生 效， 因 为 一 旦 其 进 入 主 操 作 界 面（ 功 能 选 择 界 面）， 控 制 机 制 就 会 发 生 作 用。
---- 以 上 两 种 控 制 方 式 也 有 其 不 足 之 处， 即 其 控 制 对 象 是 系 统 功 能 调 用。 由 于 一 个 系 统 的 功 能 调 用 是 固 定 设 置 在 主 操 作 界 面 中 的， 所 以 如 果 系 统 以 后 需 添 加 新 功 能， 则 控 制 机 制 代 码 就 需 要 加 入 对 新 增 功 能 调 用 的 控 制（ 在Case 代 码 区 中）。

---- 3. 触 发 检 查 型（Triggering Check Style）

---- 该 类 型 的 运 行 控 制 方 式 是 用 户 一 旦 选 择 某 项 操 作 则 立 刻 激 活 权 限 检 查， 决 定 其 是 否 有 权 执 行 该 项 操 作， 若 有 则 执 行 该 操 作， 否 则 系 统 将 拒 绝 执 行。

---- 实 现 过 程： 将 权 限 检 查 放 入 功 能 调 用 模 块 代 码 的 首 部， 由 其 决 定 是 否 执 行 该 操 作。 例 如 调 用 操 作Fun1， 则 在Fun1 的 调 用 模 块 首 部 写 入：

UserID:=Get_CurrentUser; //取得当前用户标识
Fun:=Get_CurrentOperation;//捕获操作名称
Qx:=Get_Qx(Fun); //取得该操作的对应权限
IF Having(UserID,Qx) then Call_Function(Fun)
//若拥有此操作权限则执行
Else Refuse("您无权执行该操作，请与系统管理员联系！")；
---- 这 种 控 制 最 突 出 的 优 点 是: 如 果 数 据 结 构 采 用 权 限 列 表 模 式 二， 则 该 控 制 机 制 成 为 一 种 通 用 的 机 制， 可 不 加 修 改 地 用 于 各 类 应 用 系 统 之 中； 不 足 之 处 便 是 系 统 所 有 的 操 作 对 每 位 用 户 来 说 都 是 可 选 择 的， 只 有 在 操 作 选 择 之 后 才 能 确 定 能 否 执 行， 而 且 用 户 在 不 了 解 其 权 限 设 置 时， 如 果 操 作 被" 突 然 排 斥" 则 容 易 引 起 反 感 和 误 解， 所 以 应 在 用 户 手 册 中 给 出 详 细 说 明。
----

再转一篇，希望对大家有用：
权限往往是一个极其复杂的问题，但也可简单表述为这样的逻辑表达式：判断“Who对What(Which)进行How的操作”的逻辑表达式是否为真。针对不同的应用，需要根据项目的实际情况和具体架构，在维护性、灵活性、完整性等N多个方案之间比较权衡，选择符合的方案。

目标：

直观，因为系统最终会由最终用户来维护，权限分配的直观和容易理解，显得比较重要，系统不辞劳苦的实现了组的继承，除了功能的必须，更主要的就是因为它足够直观。

简单，包括概念数量上的简单和意义上的简单还有功能上的简单。想用一个权限系统解决所有的权限问题是不现实的。设计中将常常变化的“定制”特点比较强的部分判断为业务逻辑，而将常常相同的“通用”特点比较强的部分判断为权限逻辑就是基于这样的思路。

扩展，采用可继承的Group概念在支持权限以组方式定义的同时有效避免了重定义时在扩展上的困难。

现状：

对于在企业环境中的访问控制方法，一般有三种：

1.自主型访问控制方法。目前在我国的大多数的信息系统中的访问控制模块中基本是借助于自主型访问控制方法中的访问控制列表(ACLs)。

2.强制型访问控制方法。用于多层次安全级别的军事应用。

3.基于角色的访问控制方法（RBAC）。是目前公认的解决大型企业的统一资源访问控制的有效方法。其显著的两大特征是：1.减小授权管理的复杂性，降低管理开销。2.灵活地支持企业的安全策略，并对企业的变化有很大的伸缩性。

名词：

粗粒度：表示类别级，即仅考虑对象的类别(the type of object)，不考虑对象的某个特

定实例。比如，用户管理中，创建、删除，对所有的用户都一视同仁，并不区分操作的具体对象实例。

细粒度：表示实例级，即需要考虑具体对象的实例(the instance of object)，当然，细

粒度是在考虑粗粒度的对象类别之后才再考虑特定实例。比如，合同管理中，列表、删除，需要区分该合同实例是否为当前用户所创建。 原则：

权限逻辑配合业务逻辑。即权限系统以为业务逻辑提供服务为目标。相当多细粒度的权限问题因其极其独特而不具通用意义，它们也能被理解为是“业务逻辑”的一部分。比如，要求：“合同资源只能被它的创建者删除，与创建者同组的用户可以修改，所有的用户能够浏览”。这既可以认为是一个细粒度的权限问题，也可以认为是一个业务逻辑问题。在这里它是业务逻辑问题，在整个权限系统的架构设计之中不予过多考虑。当然，权限系统的架构也必须要能支持这样的控制判断。或者说，系统提供足够多但不是完全的控制能力。即，设计原则归结为：“系统只提供粗粒度的权限，细粒度的权限被认为是业务逻辑的职责”。 需要再次强调的是，这里表述的权限系统仅是一个“不完全”的权限系统，即，它不提供所有关于权限的问题的解决方法。它提供一个基础，并解决那些具有“共性”的(或者说粗粒度的)部分。在这个基础之上，根据“业务逻辑”的独特权限需求，编码实现剩余部分(或者说细粒度的)部分，才算完整。回到权限的问题公式，通用的设计仅解决了Who+What+How 的问题，其他的权限问题留给业务逻辑解决。

概念：

Who：权限的拥用者或主体（Principal、User、Group、Role、Actor等等）

What：权限针对的对象或资源（Resource、Class）。

How：具体的权限（Privilege, 正向授权与负向授权）。

Role：是角色，拥有一定数量的权限。

Operator：操作。表明对What的How 操作。

说明：

User：与 Role 相关，用户仅仅是纯粹的用户，权限是被分离出去了的。User是不能与 Privilege 直接相关的，User 要拥有对某种资源的权限，必须通过Role去关联。解决 Who 的问题。

Resource：就是系统的资源，比如部门新闻，文档等各种可以被提供给用户访问的对象。资源可以反向包含自身，即树状结构，每一个资源节点可以与若干指定权限类别相关可定义是否将其权限应用于子节点。

Privilege：是Resource Related的权限。就是指，这个权限是绑定在特定的资源实例上的。比如说部门新闻的发布权限，叫做"部门新闻发布权限"。这就表明，该Privilege是一个发布权限，而且是针对部门新闻这种资源的一种发布权限。Privilege是由Creator在做开发时就确定的。权限，包括系统定义权限和用户自定义权限用户自定义权限之间可以指定排斥和包含关系(如：读取，修改，管理三个权限，管理 权限 包含 前两种权限)。Privilege 如"删除" 是一个抽象的名词，当它不与任何具体的 Object 或 Resource 绑定在一起时是没有任何意义的。拿新闻发布来说，发布是一种权限，但是只说发布它是毫无意义的。因为不知道发布可以操作的对象是什么。只有当发布与新闻结合在一起时，才会产生真正的 Privilege。这就是 Privilege Instance。权限系统根据需求的不同可以延伸生很多不同的版本。

Role：是粗粒度和细粒度(业务逻辑)的接口，一个基于粗粒度控制的权限框架软件，对外的接口应该是Role，具体业务实现可以直接继承或拓展丰富Role的内容，Role不是如同User或Group的具体实体，它是接口概念，抽象的通称。

Group：用户组，权限分配的单位与载体。权限不考虑分配给特定的用户。组可以包括组(以实现权限的继承)。组可以包含用户，组内用户继承组的权限。Group要实现继承。即在创建时必须要指定该Group的Parent是什么Group。在粗粒度控制上，可以认为，只要某用户直接或者间接的属于某个Group那么它就具备这个Group的所有操作许可。细粒度控制上，在业务逻辑的判断中，User仅应关注其直接属于的Group，用来判断是否“同组” 。Group是可继承的，对于一个分级的权限实现，某个Group通过“继承”就已经直接获得了其父Group所拥有的所有“权限集合”，对这个Group而言，需要与权限建立直接关联的，仅是它比起其父Group需要“扩展”的那部分权限。子组继承父组的所有权限，规则来得更简单，同时意味着管理更容易。为了更进一步实现权限的继承，最直接的就是在Group上引入“父子关系”。

User与Group是多对多的关系。即一个User可以属于多个Group之中，一个Group可以包括多个User。子Group与父Group是多对一的关系。Operator某种意义上类似于Resource + Privilege概念，但这里的Resource仅包括Resource Type不表示Resource Instance。Group 可以直接映射组织结构，Role 可以直接映射组织结构中的业务角色，比

较直观，而且也足够灵活。Role对系统的贡献实质上就是提供了一个比较粗颗粒的分配单位。

Group与Operator是多对多的关系。各概念的关系图示如下：

解释：

Operator的定义包括了Resource Type和Method概念。即，What和How的概念。之所以将What和How绑定在一起作为一个Operator概念而不是分开建模再建立关联，这是因为很多的How对于某What才有意义。比如，发布操作对新闻对象才有意义，对用户对象则没有意义。

How本身的意义也有所不同，具体来说，对于每一个What可以定义N种操作。比如，对于合同这类对象，可以定义创建操作、提交操作、检查冲突操作等。可以认为，How概念对应于每一个商业方法。其中，与具体用户身份相关的操作既可以定义在操作的业务逻辑之中，也可以定义在操作级别。比如，创建者的浏览视图与普通用户的浏览视图要求内容不同。既可以在外部定义两个操作方法，也可以在一个操作方法的内部根据具体逻辑进行处理。具体应用哪一种方式应依据实际情况进行处理。

这样的架构，应能在易于理解和管理的情况下，满足绝大部分粗粒度权限控制的功能需要。但是除了粗粒度权限，系统中必然还会包括无数对具体Instance的细粒度权限。这些问题，被留给业务逻辑来解决，这样的考虑基于以下两点：

一方面，细粒度的权限判断必须要在资源上建模权限分配的支持信息才可能得以实现。比如，如果要求创建者和普通用户看到不同的信息内容，那么，资源本身应该有其创建者的信息。另一方面，细粒度的权限常常具有相当大的业务逻辑相关性。对不同的业务逻辑，常常意味着完全不同的权限判定原则和策略。相比之下，粗粒度的权限更具通用性，将其实现为一个架构，更有重用价值；而将细粒度的权限判断实现为一个架构级别的东西就显得繁琐，而且不是那么的有必要，用定制的代码来实现就更简洁，更灵活。

所以细粒度控制应该在底层解决，Resource在实例化的时候，必需指定Owner和GroupPrivilege在对Resource进行操作时也必然会确定约束类型：究竟是OwnerOK还是GroupOK还是AllOK。Group应和Role严格分离User和Group是多对多的关系，Group只用于对用户分类，不包含任何Role的意义；Role只授予User，而不是Group。如果用户需要还没有的多种Privilege的组合，必须新增Role。Privilege必须能够访问Resource，同时带User参数，这样权限控制就完备了。

思想：

权限系统的核心由以下三部分构成：1.创造权限，2.分配权限，3.使用权限，然后，系统各部分的主要参与者对照如下：1.创造权限 - Creator创造，2.分配权限 - Administrator 分配，3.使用权限 - User：

1. Creator 创造 Privilege， Creator 在设计和实现系统时会划分，一个子系统或称为模块，应该有哪些权限。这里完成的是 Privilege 与 Resource 的对象声明，并没有真正将 Privilege 与具体Resource 实例联系在一起，形成Operator。

2. Administrator 指定 Privilege 与 Resource Instance 的关联。在这一步， 权限真正与资源实例联系到了一起， 产生了Operator（Privilege Instance）。Administrator利用Operator这个基本元素，来创造他理想中的权限模型。如，创建角色，创建用户组，给用户组分配用户，将用户组与角色关联等等...这些操作都是由 Administrator 来完成的。

3. User 使用 Administrator 分配给的权限去使用各个子系统。Administrator 是用户，在他的心目中有一个比较适合他管理和维护的权限模型。于是，程序员只要回答一个问题，就是什么权限可以访问什么资源，也就是前面说的 Operator。程序员提供 Operator 就意味着给系统穿上了盔甲。Administrator 就可以按照他的意愿来建立他所希望的权限框架可以自行增加，删除，管理Resource和Privilege之间关系。可以自行设定用户User和角色Role的对应关系。(如果将 Creator看作是 Basic 的发明者， Administrator 就是 Basic 的使用者，他可以做一些脚本式的编程) Operator是这个系统中最关键的部分，它是一个纽带，一个系在Programmer，Administrator，User之间的纽带。

用一个功能模块来举例子。

一．建立角色功能并做分配：

1．如果现在要做一个员工管理的模块(即Resources)，这个模块有三个功能，分别是：增加，修改，删除。给这三个功能各自分配一个ID，这个ID叫做功能代号：

Emp_addEmp，Emp_deleteEmp，Emp_updateEmp。

2．建立一个角色(Role)，把上面的功能代码加到这个角色拥有的权限中，并保存到数据库中。角色包括系统管理员，测试人员等。

3．建立一个员工的账号，并把一种或几种角色赋给这个员工。比如说这个员工既可以是公司管理人员，也可以是测试人员等。这样他登录到系统中将会只看到他拥有权限的那些模块。

二．把身份信息加到Session中。

登录时，先到数据库中查找是否存在这个员工，如果存在，再根据员工的sn查找员工的权限信息，把员工所有的权限信息都入到一个Hashmap中，比如就把上面的Emp_addEmp等放到这个Hashmap中。然后把Hashmap保存在一个UserInfoBean中。最后把这个UserInfoBean放到Session中，这样在整个程序的运行过程中，系统随时都可以取得这个用户的身份信息。

三．根据用户的权限做出不同的显示。

可以对比当前员工的权限和给这个菜单分配的“功能ID”判断当前用户是否有打开这个菜单的权限。例如：如果保存员工权限的Hashmap中没有这三个ID的任何一个，那这个菜单就不会显示，如果员工的Hashmap中有任何一个ID，那这个菜单都会显示。

对于一个新闻系统(Resouce)，假设它有这样的功能(Privilege)：查看，发布，删除，修改；假设对于删除，有"新闻系统管理者只能删除一月前发布的，而超级管理员可删除所有的这样的限制，这属于业务逻辑(Business logic)，而不属于用户权限范围。也就是说权限负责有没有删除的Permission，至于能删除哪些内容应该根据UserRole or UserGroup来决定(当然给UserRole or UserGroup分配权限时就应该包含上面两条业务逻辑)。

一个用户可以拥有多种角色，但同一时刻用户只能用一种角色进入系统。角色的划分方法可以根据实际情况划分，按部门或机构进行划分的，至于角色拥有多少权限，这就看系统管理员赋给他多少的权限了。用户―角色―权限的关键是角色。用户登录时是以用户和角色两种属性进行登录的（因为一个用户可以拥有多种角色，但同一时刻只能扮演一种角色），根据角色得到用户的权限，登录后进行初始化。这其中的技巧是同一时刻某一用户只能用一种角色进行登录。

针对不同的“角色”动态的建立不同的组，每个项目建立一个单独的Group，对于新的项目，建立新的 Group 即可。在权限判断部分，应在商业方法上予以控制。比如：不同用户的“操作能力”是不同的(粗粒度的控制应能满足要求)，不同用户的“可视区域”是不同的(体现在对被操作的对象的权限数据，是否允许当前用户访问，这需要对业务数据建模的时候考虑权限控制需要)。

扩展性：

有了用户/权限管理的基本框架，Who(User/Group)的概念是不会经常需要扩展的。变化的可能是系统中引入新的 What (新的Resource类型)或者新的How(新的操作方式)。那在三个基本概念中，仅在Permission上进行扩展是不够的。这样的设计中Permission实质上解决了How 的问题，即表示了“怎样”的操作。那么这个“怎样”是在哪一个层次上的定义呢？将Permission定义在“商业方法”级别比较合适。比如，发布、购买、取消。每一个商业方法可以意味着用户进行的一个“动作”。定义在商业逻辑的层次上，一方面保证了数据访问代码的“纯洁性”，另一方面在功能上也是“足够”的。也就是说，对更低层次，能自由的访问数据，对更高层次，也能比较精细的控制权限。 确定了Permission定义的合适层次，更进一步，能够发现Permission实际上还隐含了What的概念。也就是说，对于What的How操作才会是一个完整的Operator。比如，“发布”操作，隐含了“信息”的“发布”概念，而对于“商品”而言发布操作是没有意义的。同样的，“购买”操作，隐含了“商品”的“购买”概念。这里的绑定还体现在大量通用的同名的操作上，比如，需要区分“商品的删除”与“信息的删除”这两个同名为“删除”的不同操作。

提供权限系统的扩展能力是在Operator (Resource + Permission)的概念上进行扩展。Proxy 模式是一个非常合适的实现方式。实现大致如下：在业务逻辑层(EJB Session Facade [Stateful SessionBean]中)，取得该商业方法的Methodname，再根据Classname和 Methodname 检索Operator 数据，然后依据这个Operator信息和Stateful中保存的User信息判断当前用户是否具备该方法的操作权限。

应用在 EJB 模式下，可以定义一个很明确的 Business层次，而一个Business 可能意味着不同的视图，当多个视图都对应于一个业务逻辑的时候，比如，Swing Client以及 Jsp Client 访问的是同一个 EJB 实现的 Business。在 Business 层上应用权限较能提供集中的控制能力。实际上，如果权限系统提供了查询能力，那么会发现，在视图层次已经可以不去理解权限，它只需要根据查询结果控制界面就可以了。

灵活性：

Group和Role，只是一种辅助实现的手段，不是必需的。如果系统的Role很多，逐个授权违背了“简单，方便”的目的，那就引入Group，将权限相同的Role组成一个Group进行集中授权。Role也一样，是某一类Operator的集合，是为了简化针对多个Operator的操作。

Role把具体的用户和组从权限中解放出来。一个用户可以承担不同的角色，从而实现授权的灵活性。当然，Group也可以实现类似的功能。但实际业务中，Group划分多以行政组织结构或业务功能划分；如果为了权限管理强行将一个用户加入不同的组，会导致管理的复杂性。 Domain的应用。为了授权更灵活，可以将Where或者Scope抽象出来，称之为Domain，真正的授权是在Domain的范围内进行，具体的Resource将分属于不同的Domain。比如：一个新闻机构有国内与国外两大分支，两大分支内又都有不同的资源（体育类、生活类、时事政治类）。假如所有国内新闻的权限规则都是一样的，所有国外新闻的权限规则也相同。则可以建立两个域，分别授权，然后只要将各类新闻与不同的域关联，受域上的权限控制，从而使之简化。

权限系统还应该考虑将功能性的授权与资源性的授权分开。很多系统都只有对系统中的数据（资源）的维护有权限控制，但没有对系统功能的权限控制。 权限系统最好是可以分层管理而不是集中管理。大多客户希望不同的部门能且仅能管理其部门内部的事务，而不是什么都需要一个集中的Administrator或Administrators组来管理。虽然你可以将不同部门的人都加入Administrators组，但他们的权限过大，可以管理整个系统资源而不是该部门资源。

正向授权与负向授权：正向授权在开始时假定主体没有任何权限，然后根据需要授予权限，适合于权限要求严格的系统。负向授权在开始时假定主体有所有权限，然后将某些特殊权限收回。

权限计算策略：系统中User，Group，Role都可以授权，权限可以有正负向之分，在计算用户的净权限时定义一套策略。

系统中应该有一个集中管理权限的AccessService，负责权限的维护（业务管理员、安全管理模块）与使用（最终用户、各功能模块），该AccessService在实现时要同时考虑一般权限与特殊权限。虽然在具体实现上可以有很多，比如用Proxy模式，但应该使这些Proxy依赖于AccessService。各模块功能中调用AccessService来检查是否有相应的权限。所以说，权限管理不是安全管理模块自己一个人的事情，而是与系统各功能模块都有关系。每个功能模块的开发人员都应该熟悉安全管理模块，当然，也要从业务上熟悉本模块的安全规则。 技术实现：

1．表单式认证，这是常用的，但用户到达一个不被授权访问的资源时，Web容器就发

出一个html页面，要求输入用户名和密码。

2．一个基于Servlet Sign in/Sign out来集中处理所有的Request，缺点是必须由应用程序自己来处理。

3．用Filter防止用户访问一些未被授权的资源，Filter会截取所有Request/Response，

然后放置一个验证通过的标识在用户的Session中，然后Filter每次依靠这个标识来决定是否放行Response。

这个模式分为：

Gatekeeper ：采取Filter或统一Servlet的方式。

Authenticator： 在Web中使用JAAS自己来实现。

用户资格存储LDAP或数据库：

1. Gatekeeper拦截检查每个到达受保护的资源。首先检查这个用户是否有已经创建

好的Login Session，如果没有，Gatekeeper 检查是否有一个全局的和Authenticator相关的session？

2. 如果没有全局的session，这个用户被导向到Authenticator的Sign-on 页面，

要求提供用户名和密码。

3. Authenticator接受用户名和密码，通过用户的资格系统验证用户。

4. 如果验证成功，Authenticator将创建一个全局Login session，并且导向Gatekeeper

来为这个用户在他的web应用中创建一个Login Session。

5. Authenticator和Gatekeepers联合分享Cookie，或者使用Tokens在Query字符里。

club.AMTeam.org

不好意思，我没仔细看就下结论了，这里还是有很多对权限设计的讨论的。呵呵，所以说“没有调查就没有发言权”是真理啊。这里的帖子对我很有帮助。可能大家对实际的开发的讨论更赶兴趣，所以想这种汇总性的问题，大家都不太愿意做，不过做 做还是有好处的噢！：）