基于 Java 实现的将已有 RBAC（基于角色的访问控制）权限管理系统改造为层级权限管理系统的示例。我们假设已经有一个简单的 RBAC 系统，现在要在此基础上

基于 Java 实现的将已有 RBAC（基于角色的访问控制）权限管理系统改造为层级权限管理系统的示例。我们假设已经有一个简单的 RBAC 系统，现在要在此基础上添加层级关系

1. 原 RBAC 系统设计

首先回顾一下简单的 RBAC 系统的基本组件：用户（User）、角色（Role）和权限（Permission）。

实体类定义

import java.util.ArrayList;
import java.util.List;

// 权限类
class Permission {
    private String name;

    public Permission(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 角色类
class Role {
    private String name;
    private List<Permission> permissions;

    public Role(String name) {
        this.name = name;
        this.permissions = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public List<Permission> getPermissions() {
        return permissions;
    }

    public void addPermission(Permission permission) {
        permissions.add(permission);
    }
}

// 用户类
class User {
    private String name;
    private List<Role> roles;

    public User(String name) {
        this.name = name;
        this.roles = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public List<Role> getRoles() {
        return roles;
    }

    public void addRole(Role role) {
        roles.add(role);
    }

    public boolean hasPermission(Permission permission) {
        for (Role role : roles) {
            if (role.getPermissions().contains(permission)) {
                return true;
            }
        }
        return false;
    }
}

2. 改造为层级权限管理系统

为了实现层级权限管理，我们需要引入角色的层级关系，即父角色和子角色。子角色可以继承父角色的权限，并且可以有自己额外的权限。

改造后的角色类

import java.util.ArrayList;
import java.util.List;

class HierarchicalRole {
    private String name;
    private List<Permission> permissions;
    private HierarchicalRole parent;
    private List<HierarchicalRole> children;

    public HierarchicalRole(String name) {
        this.name = name;
        this.permissions = new ArrayList<>();
        this.children = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public List<Permission> getPermissions() {
        List<Permission> allPermissions = new ArrayList<>(permissions);
        if (parent != null) {
            allPermissions.addAll(parent.getPermissions());
        }
        return allPermissions;
    }

    public void addPermission(Permission permission) {
        permissions.add(permission);
    }

    public HierarchicalRole getParent() {
        return parent;
    }

    public void setParent(HierarchicalRole parent) {
        this.parent = parent;
        parent.children.add(this);
    }

    public List<HierarchicalRole> getChildren() {
        return children;
    }
}

改造后的用户类

import java.util.ArrayList;
import java.util.List;

class HierarchicalUser {
    private String name;
    private List<HierarchicalRole> roles;

    public HierarchicalUser(String name) {
        this.name = name;
        this.roles = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public List<HierarchicalRole> getRoles() {
        return roles;
    }

    public void addRole(HierarchicalRole role) {
        roles.add(role);
    }

    public boolean hasPermission(Permission permission) {
        for (HierarchicalRole role : roles) {
            if (role.getPermissions().contains(permission)) {
                return true;
            }
        }
        return false;
    }
}

3. 使用示例

public class HierarchicalRBACExample {
    public static void main(String[] args) {
        // 创建权限
        Permission readPermission = new Permission("read");
        Permission writePermission = new Permission("write");
        Permission deletePermission = new Permission("delete");

        // 创建角色
        HierarchicalRole adminRole = new HierarchicalRole("Admin");
        adminRole.addPermission(readPermission);
        adminRole.addPermission(writePermission);
        adminRole.addPermission(deletePermission);

        HierarchicalRole userRole = new HierarchicalRole("User");
        userRole.setParent(adminRole);
        userRole.addPermission(readPermission);

        // 创建用户
        HierarchicalUser user = new HierarchicalUser("John");
        user.addRole(userRole);

        // 检查权限
        System.out.println("User has read permission: " + user.hasPermission(readPermission));
        System.out.println("User has write permission: " + user.hasPermission(writePermission));
        System.out.println("User has delete permission: " + user.hasPermission(deletePermission));
    }
}

代码解释

HierarchicalRole 类：

• 增加了 parent 字段来表示父角色，children 字段来表示子角色列表。

• getPermissions 方法会递归获取父角色的权限，从而实现权限的继承。 HierarchicalUser 类：

• 角色列表使用 HierarchicalRole 类型。

• hasPermission 方法会检查用户所拥有的角色及其继承的权限是否包含指定的权限。

使用示例：

• 创建了不同的权限和角色，设置了角色的层级关系。
• 创建用户并分配角色，最后检查用户的权限。
• 通过这种方式，我们将原有的 RBAC 系统改造为了层级权限管理系统，实现了角色之间的权限继承。