权限管理:ACL 授权与即时认证
导读
本篇围绕「权限管理:ACL 授权与即时认证」展开,先给出可以直接复用的结论,再逐步拆解背后的机制。
权限是 OA 系统的灵魂。这一篇是整个项目最值得反复读的部分:它用一张表 + 位运算 + 继承标记实现了一套完整的 RBAC(基于角色的访问控制)与用户级授权并存的方案。
一、先厘清概念
| 概念 | 含义 | 本项目中的实现 |
|---|---|---|
| 主体(Principal) | 谁 | 用户(User)或角色(Role) |
| 资源(Resource) | 对什么 | 模块(Module),用 sn 唯一标识 |
| 权限(Permission) | 做什么 | 增(C)、查(R)、改(U)、删(D) |
| 授权(Authorization) | 给主体分配对某资源的某种权限 | 写一条 ACL 记录 |
| 认证(Authentication) | 判断某主体对某资源是否有某权限 | hasPermission() |
| 继承 | 用户级授权是否覆盖角色级授权 | aclTriState |
一句话模型:ACL = 主体 + 资源 + 权限集合 + 是否继承。
二、权限的位运算表示
四种权限用四个 bit 表示,常量定义在 Permission 中:
public class Permission {
public static final int CREATE = 0; // 第 0 位 → 1
public static final int READ = 1; // 第 1 位 → 2
public static final int UPDATE = 2; // 第 2 位 → 4
public static final int DELETE = 3; // 第 3 位 → 8
}
于是 aclState 这个 int 字段就同时存下了四种权限的有无:
| 权限组合 | 二进制 | aclState |
|---|---|---|
| 无权限 | 0000 |
0 |
| 只读 | 0010 |
2 |
| 读 + 增 | 0011 |
3 |
| 全权限 | 1111 |
15 |
2.1 ACL 实体
/**
* @hibernate.class table="T_ACL"
*/
public class ACL {
public static final String TYPE_ROLE = "Role";
public static final String TYPE_USER = "User";
public static final int ACL_YES = 1; // 授权:允许
public static final int ACL_NO = 0; // 授权:不允许
public static final int ACL_NEUTRAL = -1; // 未确定(继承)
private int id;
private String principalType; // "User" 或 "Role"
private int principalSn; // 用户 ID 或角色 ID
private int resourceSn; // 模块 ID
private int aclState; // 权限位
private int aclTriState; // 0 表示不继承;0xFFFFFFFF(-1) 表示继承
/** 设置某位权限 */
public void setPermission(int permission, boolean yes) {
int tmp = 1;
tmp = tmp << permission; // 第 permission 位置 1
if (yes) {
aclState |= tmp; // 置位
} else {
aclState &= ~tmp; // 清位
}
}
/** 获取某位权限:允许 / 不允许 / 未确定 */
public int getPermission(int permission) {
if (aclTriState == 0xFFFFFFFF) { // 继承标记:本条不做决定
return ACL_NEUTRAL;
}
int tmp = 1;
tmp = tmp << permission;
tmp &= aclState;
return tmp != 0 ? ACL_YES : ACL_NO;
}
/** 设置用户级授权是否继承(true = 继承角色授权) */
public void setExtends(boolean yes) {
aclTriState = yes ? 0xFFFFFFFF : 0;
}
}
设计亮点:aclTriState 用一个特殊值 -1(0xFFFFFFFF)表示"这条用户级授权不表态,请去看角色级授权"。这样只用一个字段就表达了三态逻辑:允许 / 不允许 / 不确定。
三、授权:写 ACL 记录
public void addOrUpdatePermission(String principalType, int principalSn,
int resourceSn, int permission, boolean yes) {
// 1. 查找是否已有该主体对该资源的 ACL 记录
ACL acl = findACL(principalType, principalSn, resourceSn);
// 2. 有则更新权限位
if (acl != null) {
acl.setPermission(permission, yes);
getHibernateTemplate().update(acl);
return;
}
// 3. 无则新建
acl = new ACL();
acl.setPrincipalType(principalType);
acl.setPrincipalSn(principalSn);
acl.setResourceSn(resourceSn);
acl.setPermission(permission, yes);
getHibernateTemplate().save(acl);
}
设置用户级继承特性:
public void addOrUpdateUserExtends(int userId, int resourceSn, boolean yes) {
ACL acl = findACL(ACL.TYPE_USER, userId, resourceSn);
if (acl != null) {
acl.setExtends(yes);
getHibernateTemplate().update(acl);
return;
}
acl = new ACL();
acl.setPrincipalType(ACL.TYPE_USER);
acl.setPrincipalSn(userId);
acl.setResourceSn(resourceSn);
acl.setExtends(yes);
getHibernateTemplate().save(acl);
}
删除授权:
public void delPermission(String principalType, int principalSn, int resourceSn) {
getHibernateTemplate().delete(findACL(principalType, principalSn, resourceSn));
}
授权界面通常是一个矩阵:行是模块,列是 C/R/U/D 四个复选框,外加一个"继承"复选框。勾选即调
addOrUpdatePermission(..., true),取消即传false。
四、认证:判断有没有权限
这是整个权限系统的核心算法:
public boolean hasPermission(int userId, int resourceSn, int permission) {
// 1. 先查直接授予用户的授权
ACL acl = findACL(ACL.TYPE_USER, userId, resourceSn);
if (acl != null) {
int yesOrNo = acl.getPermission(permission);
// 用户的授权是"确定"的,直接返回
if (yesOrNo != ACL.ACL_NEUTRAL) {
return yesOrNo == ACL.ACL_YES;
}
}
// 2. 用户授权不确定 → 按角色优先级依次查找
String hql = "select r.id from UsersRoles ur join ur.role r join ur.user u "
+ "where u.id = ? order by ur.orderNo";
List aclIds = getHibernateTemplate().find(hql, userId);
for (Iterator iter = aclIds.iterator(); iter.hasNext();) {
Integer rid = (Integer) iter.next();
acl = findACL(ACL.TYPE_ROLE, rid, resourceSn);
// 3. 一旦发现某个角色有明确授权,立即返回
if (acl != null) {
return acl.getPermission(permission) == ACL.ACL_YES;
}
}
// 4. 默认拒绝
return false;
}
判定顺序(非常重要):
用户级授权 ──确定──> 返回结果
│
└─不确定(继承)──> 按 orderNo 升序遍历角色 ──找到 ACL──> 返回结果
│
└─都没有──> false(默认拒绝)
这就是为什么 UsersRoles 需要一个 orderNo 字段:一个用户可能属于多个角色,角色之间有优先级,优先级高的角色授权先被采纳。
public class UsersRoles { // T_UsersRoles
private int id;
private Role role;
private User user;
private int orderNo; // 角色优先级,数字越小优先级越高
}
默认拒绝原则:没有任何授权记录时返回 false,而不是 true。安全系统的默认行为必须是拒绝。
五、登录后的导航菜单:搜索用户有权限的模块
登录成功后,首页要列出"当前用户能看到的模块"。算法如下:
public List searchModules(int userId) {
Map temp = new HashMap(); // key = resourceSn, value = ACL
// 1. 按优先级从低到高收集角色的授权(低的先放,高的后放会覆盖低的)
String hql = "select r.id from UsersRoles ur join ur.role r join ur.user u "
+ "where u.id = ? order by ur.orderNo desc";
List aclIds = getHibernateTemplate().find(hql, userId);
for (Iterator iter = aclIds.iterator(); iter.hasNext();) {
Integer rid = (Integer) iter.next();
List acls = findRoleACLs(rid);
for (Iterator iterator = acls.iterator(); iterator.hasNext();) {
ACL acl = (ACL) iterator.next();
temp.put(acl.getResourceSn(), acl); // 同一资源被高优先级角色覆盖
}
}
// 2. 再放用户级授权(用户级最终覆盖角色级)
List acls = findUserACLs(userId);
for (Iterator iter = acls.iterator(); iter.hasNext();) {
ACL acl = (ACL) iter.next();
temp.put(acl.getResourceSn(), acl);
}
// 3. 剔除没有读权限的资源
List delResources = new ArrayList();
for (Iterator iter = temp.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = (Map.Entry) iter.next();
ACL acl = (ACL) entry.getValue();
if (acl.getPermission(Permission.READ) == ACL.ACL_NO) {
delResources.add(entry.getKey());
}
}
for (Iterator iter = delResources.iterator(); iter.hasNext();) {
temp.remove(iter.next());
}
if (temp.isEmpty()) return new ArrayList();
// 4. 一次性查出模块对象
return getSession().createQuery("select m from Module m where m.id in (:ids)")
.setParameterList("ids", temp.keySet())
.list();
}
注意第 1 步用的是 orderNo desc(从低优先级到高优先级),这样后放入的高优先级角色会覆盖先放入的;第 2 步用户级最后放入,覆盖所有角色级。这与 hasPermission() 的"从高到低找第一个"在效果上是一致的。
六、授权一览:用 SQL 位运算直接取
授权界面要展示"某主体对所有模块的 C/R/U/D 勾选状态",一条原生 SQL 就够:
public List searchAclRecord(String principalType, int principalSn) {
String sql = "select resourceSn, aclState&1, aclState&2, "
+ "aclState&4, aclState&8, aclTriState "
+ "from T_ACL where principalType = '" + principalType
+ "' and principalSn = " + principalSn;
return getSession().createSQLQuery(sql).list();
}
| 表达式 | 含义 |
|---|---|
aclState & 1 |
是否有 CREATE 权限 |
aclState & 2 |
是否有 READ 权限 |
aclState & 4 |
是否有 UPDATE 权限 |
aclState & 8 |
是否有 DELETE 权限 |
这条 SQL 是字符串拼接的,存在注入风险。实际项目应改成
setParameter参数绑定。
七、把权限用到页面上
7.1 登录拦截:BaseAction
所有后台 Action 继承 BaseAction,在 execute() 里统一做登录校验:
public class BaseAction extends DispatchAction {
@Override
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) throws Exception {
User user = (User) request.getSession().getAttribute("login");
if (user == null) {
return mapping.findForward("login"); // 未登录 → 跳登录页
}
return super.execute(mapping, form, request, response); // 继续分发
}
protected User currentUser(HttpServletRequest request) {
return (User) request.getSession().getAttribute("login");
}
}
7.2 即时认证:JSTL 函数
页面上的按钮要不要显示,取决于当前用户有没有对应权限。做法是定义一个静态函数,通过 .tld 暴露成 EL 函数:
public class SecurityFunctions {
private static AclManager aclManager;
public static boolean hasPermission(int userId, String resourceSn, int permission) {
return aclManager.hasPermissionByResourceSn(userId, resourceSn, permission);
}
// 注意:setter 不能是 static,否则 Spring 无法注入
public void setAclManager(AclManager aclManager) {
SecurityFunctions.aclManager = aclManager;
}
}
Spring 配置:
<bean id="securityFunctions" class="com.oa.web.SecurityFunctions">
<property name="aclManager" ref="aclManager"/>
</bean>
my.tld:
<function>
<name>hasPermission</name>
<function-class>com.oa.web.SecurityFunctions</function-class>
<function-signature>boolean hasPermission(int, java.lang.String, int)</function-signature>
</function>
JSP 中使用——没权限的按钮根本不会渲染出来:
<c:if test="${my:hasPermission(login.id, 'document', 0)}">
<a href="document.do?method=addInput">新建公文</a>
</c:if>
<c:if test="${my:hasPermission(login.id, 'document', 3)}">
<a href="javascript:del()">删除</a>
</c:if>
前端隐藏只是体验优化,服务端仍必须在 Action 或 Manager 里再校验一次,否则直接构造 URL 就能越权。
7.3 按资源标识认证
页面上用的是模块 sn(字符串),而 ACL 里存的是模块 ID,需要一层转换:
public boolean hasPermissionByResourceSn(int userId, String resourceSn, int permission) {
String hql = "select m.id from Module m where m.sn = ? ";
return hasPermission(
userId,
(Integer) getSession().createQuery(hql).setParameter(0, resourceSn).uniqueResult(),
permission);
}
八、模块(Module)设计
/**
* @hibernate.class table="T_Module"
*/
public class Module {
private int id;
private String name; // 模块名称,唯一
private String sn; // 模块标识,唯一(如 "document")
...
}
sn 是硬编码在页面与代码里的"资源代号",授权界面按 sn 列出模块。新增功能模块时,只要在 T_Module 里加一条记录,并在 JSP 里用对应 sn 做权限判断即可,不需要改权限系统的代码。
九、完整调用链
用户登录
└─> LoginAction:校验账号密码,把 User 放入 session("login")
└─> IndexAction:aclManager.searchModules(userId) → 导航菜单
访问 /document.do?method=add
└─> BaseAction.execute:session 里没有 login?→ 跳登录页
└─> DocumentAction.add()
渲染 JSP
└─> ${my:hasPermission(login.id,'document',0)}
└─> SecurityFunctions.hasPermission
└─> AclManager.hasPermissionByResourceSn
└─> sn → id → AclManager.hasPermission
├─ 查用户级 ACL:确定则返回
└─ 不确定 → 按角色优先级查角色级 ACL → 返回
十、常见问题
Q:为什么不直接用 Spring Security / Shiro? 这是一个 2007 年代的教学项目,目标是把权限模型讲透。理解了 ACL 的三态设计后,再看任何权限框架都会很快。而现在的新项目应当直接使用成熟框架。
Q:角色优先级一定需要吗?
不一定。如果一个人只属于一个角色(绝大多数系统如此),orderNo 可以去掉。保留它是为了支持"身兼多职"时的授权仲裁。
Q: aclTriState == 0xFFFFFFFF 判断有坑吗?
有。0xFFFFFFFF 作为 int 就是 -1,所以判断写 aclTriState == -1 更直观。另外它依赖 32 位补码表示,可移植性一般,实际项目建议改用枚举或单独的布尔字段。
Q:如何支持"数据级权限"(只能看本部门的数据)?
本项目只做到"功能级权限"。数据级权限需要额外在查询里拼条件,例如按 person.org.sn LIKE '1_3%' 过滤,这属于另一个话题。
要点小结
- | 概念 | 含义 | 本项目中的实现 | |---|---|---| | 主体(Principal) | 谁 | 用户(User)或角色(Role) | | 资源(Reso…
- 四种权限用四个 bit 表示,常量定义在
Permission中: ```java public class Permission { public stat… -
- 安全系统的默认行为必须是拒绝。
由站内小编编辑整理