A
📖 知识库
🌐

权限管理:ACL 授权与即时认证

📄 组织与权限 30 分钟阅读 84 次浏览 更新于 2026-10-25

导读

本篇围绕「权限管理: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…
  • 安全系统的默认行为必须是拒绝。

由站内小编编辑整理

相关条目