自定义RBAC（5）

时间：2022-12-14 11:01:50

您好，我是湘王，这是我的51CTO博客，欢迎您来，欢迎您再来～


把实体类及Service类都准备好了之后，就可以开始继续写业务代码了。Spring Security的强大之一就在于它的拦截器。那么这里也可以参照它的方式，实现自己的拦截器。

/**
* 权限注解
*
* @author 湘王
*/
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface PreAuthorize {
// 组
String group() default "";

// 角色
String role() default "";

// 权限
String permission() default "";
}


拦截器需要完成两个任务：

1、查找用户拥有的资源，其实分解一下，也就是要完成下面的工作

1.1、找到某个用户所属的所有组（不需要去找这些组的父组）

1.2、找到某个用户拥有的所有角色（同时要逐个找到所有这些角色的父角色）

1.3、找到某个用户拥有的所有权限

2、将权限与资源做比对，确认是否对该资源有访问权限


开始定义拦截处理器：

/**
* 拦截处理器
*
* @author 湘王
*/
@Aspect
@Component
public class InterceptorHandler {
@Autowired
private UserService userService;
@Autowired
private RoleService roleService;
@Autowired
private PermissionService permissionService;

/**
* 拦截controller包下面的所有类中，有@RequestMapping注解的方法
*/
@Pointcut("execution(* com.xiangwang.controller..*.*(..)) " +
"&& @annotation(org.springframework.web.bind.annotation.RequestMapping)")
public void controllerMethodPointcut() {
  }

/**
* 拦截器具体实现
*/
@Around("controllerMethodPointcut()")
public Object Interceptor(final ProceedingJoinPoint pjp) {
ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = sra.getRequest();
Map<String, String> argsMap = new HashMap<String, String>();
Enumeration<String> em = request.getParameterNames();
String methodName = pjp.getSignature().getName();

// 加入参数
while (em.hasMoreElements()) {
String paramName = em.nextElement();
String value = request.getParameter(paramName);
argsMap.put(paramName, value);
    }
String username = argsMap.get("username");
String platform = argsMap.get("platform");
String timestamp = argsMap.get("timestamp");
String signature = argsMap.get("signature");
// 验证参数
if (null == platform || null == timestamp || null == signature) {
return "params required";
    }

// 后端生成签名：platform = "xiangwang", timestamp = "159123456789", signature = a8354bc1b54a39528e81c549ec373c14
String sign = DigestUtils.md5DigestAsHex((platform + timestamp).getBytes());
if (!signature.equalsIgnoreCase(sign)) {
return "signature error";
    }

// 获取切面标记
Signature signatureObject = pjp.getSignature();
if (!(signatureObject instanceof MethodSignature)) {
throw new IllegalArgumentException("this annotation can be applied on method only");
    }

// 获取用户信息
SysUser user = userService.queryByUsername(username);
if (null == user) {
return "user is not exist";
    }

/**
* 获得用户拥有的全部角色
*/
// 用户所属的角色
Set<SysRole> userRoleSet = new HashSet<>();
// 用户所拥有的全部角色
Set<SysRole> userAllRoleSet = new HashSet<>();
// 查询这些角色的全部父角色
StringBuilder roleIds = new StringBuilder();
Set<String> userRoleNameSet = new HashSet<>();
// 用户-组-角色
List<SysRole> ugr = roleService.queryUGRByUserId(user.getId());
if (null != ugr && ugr.size() > 0) {
ugr.stream().forEach(r -> userRoleSet.add(r));
    }
// 用户-角色
List<SysRole> ur = roleService.queryURByUserId(user.getId());
if (null != ur && ur.size() > 0) {
ur.stream().forEach(r -> userRoleSet.add(r));
    }
// 合并全部角色
for (SysRole role : userRoleSet) {
List<SysRole> list = roleService.queryParentsById(role.getParentids());
if (null != list && list.size() > 0) {
list.stream().forEach(r -> {
userAllRoleSet.add(r);
userAllRoleSet.add(role);
        });
      }
    }
// 查询这些角色的全部权限
userAllRoleSet.stream().forEach(r -> {
roleIds.append(r.getId() + "," + r.getParentids());
userRoleNameSet.add(r.getName());
    });
List<SysPermission> rolePermissions = permissionService.queryByMultiRoleIds(roleIds.toString());

/**
* 获得用户拥有的全部权限
*/
Set<String> userPermissionSet = new HashSet<>();
// 用户-组-角色-权限
List<SysPermission> ugrp = permissionService.queryUGRPByUserId(user.getId());
if (null != ugrp && ugrp.size() > 0) {
ugrp.stream().forEach(r -> userPermissionSet.add(r.getPath()));
    }
// 用户-角色-权限
List<SysPermission> urp = permissionService.queryURPByUserId(user.getId());
if (null != urp && urp.size() > 0) {
urp.stream().forEach(r -> userPermissionSet.add(r.getPath()));
    }
// 用户-权限
List<SysPermission> up = permissionService.queryUPByUserId(user.getId());
if (null != up && up.size() > 0) {
up.stream().forEach(r -> userPermissionSet.add(r.getPath()));
    }
// 合并之前的结果
if (null != rolePermissions && rolePermissions.size() > 0) {
rolePermissions.stream().forEach(r -> userPermissionSet.add(r.getPath()));
    }

// 权限判断
Object target = pjp.getTarget();
Class<?> clazz = target.getClass();
MethodSignature methodSignature = (MethodSignature) signatureObject;
try {
Method method = target.getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());
// 获取注解类
PreAuthorize preAuthorize = method.getDeclaredAnnotation(PreAuthorize.class);
RequestMapping requestMapping = method.getDeclaredAnnotation(RequestMapping.class);
if (null != preAuthorize) {
// 只有当用户具备此角色且访问路径与权限中的path相等时才能认为具有该资源的操作权限
if (userRoleNameSet.contains(preAuthorize.role()) && userPermissionSet.contains(requestMapping.value()[0])) {
System.out.println(username + " ==> " + clazz.getSimpleName() + " - " + method.getName() + " - " +
preAuthorize.role() + " - " + requestMapping.value()[0]);
// 继续往下执行
return pjp.proceed();
        } else {
return "permission denied";
        }
      }
    } catch (NoSuchMethodException e) {
e.printStackTrace();
    } catch (Throwable throwable) {
throwable.printStackTrace();
    }

return "faliure";
  }
}


最后来定义controller：

/**
* 用户Controller
*
* @author 湘王
*/
@RestController
public class UserController {
/**
* 接口访问：
* 用例一：小林（uid=7）->组（无）->角色（产品，rid=5），结果：无权限
* 用例二：小黄（uid=9）->组（无）->角色（客服，rid=4），结果：正常访问
* 用例三：张总（uid=3）->组（gid=10001）->角色（客服、产品、运营，rid=4,5,6），结果：正常访问
*
*/
@PreAuthorize(role = "客服")
@RequestMapping(value = "/api/v1.0.0/user/details", method = RequestMethod.GET)
public String details(String username) {
return username + " 有查看用户详情的权限";
    }

/**
* 接口访问：
* 用例四：蔡总（uid=4）->组（gid=10002）->角色（会计、出纳、库管、配送，rid=7,8,9,10），结果：无权限
*
*/
@PreAuthorize(role = "产品")
@RequestMapping(value = "/api/v1.0.0/system/setting/password", method = RequestMethod.GET)
public String password(String username) {
return username + " 有修改密码的权限";
    }
}


可以通过SQL来完成测试，看看被测试用户权限的正确性

用例一：小林（uid=7）->组（无）->角色（产品，rid=5），结果：无权限

用例二：小黄（uid=9）->组（无）->角色（客服，rid=4），结果：正常访问

用例三：张总（uid=3）->组（gid=10001）->角色（客服、产品、运营，rid=4,5,6），结果：正常访问

用例四：蔡总（uid=4）->组（gid=10002）->角色（会计、出纳、库管、配送，rid=7,8,9,10），结果：无权限


查找用户资源需要注意：

1、查找权限，需要找到某个权限的所有子权限

2、查找角色，需要找到某个角色的所有父角色

4、查找组，可能需要找到父组，也可能不需要

5、想想这都是为什么？

5.1、因为权限是集合关系，角色是组合关系，组是既不是集合关系也不是聚合关系

5.2、父权限是某一类权限的代表，通过它可以找到相关的子权限

5.3、子角色是某个或某些角色的聚合/组合，这些角色组成了新角色

5.4、相对于父组，子组其实更多的是一种权限上的隔离

5.5、在设计权限系统时，需要了解这些隐含的语义逻辑和语境


最后，再来看看遗留的一个小尾巴。

之前在定义SysUser时有一个scope字段（0：全部，1：部门及以下，2：仅个人），它用来限制用户浏览数据的范围。例如，在用户通过拦截器对权限的检查以后，当需要浏览诸如会员、商品、订单时，可以依据这个条件来过滤。

具体做法就是在商品表中加入branchid和userid，然后依据scope来过滤。

1、当scope=1时，过滤条件增加branchid及以下机构（parentids LIKE '%?,%'）

2、当scope=2时，过滤条件增加userid（WHERE userid=?）


RBAC2和RBAC1的不同在于增加了一个sys_config表，用来实现权限相关的策略。这个表主要在为用户分配组、角色、权限时起作用，而不是在拦截器中验证时。例如，服务端有一个SystemController，其中有create/assign/update/remove + Group/Role/Permission之类的方法，执行这些方法时，就会从sys_config表中读取策略


例如，如果某两个角色A和B互斥，那么当给用户赋了A时，就不能再赋予用户B角色了。


而所谓二级权限，就是用户A可以把自己拥有的权限再赋予另一个用户，即权限的转授。实现二级权限也不复杂，只需要在SysPermission中增加对一个“分配权限”就行了。如果用户A有这个“分配权限”的权限，就能把自己所拥有的权限分配给另外一个用户（但仅仅限于用户A所拥有的权限），依次类推，可以有三级、四级等多级分级授权。


总的来说，权限系统所用的技术并不复杂，也可以说非常简单。但是设计权限系统的过程是比较费时费力的，也可能比较烧脑。需要对业务需求有很深入的了解，这样才能设计出既能满足需要，又简单实用的权限架构。

其实大多数权限系统，都只到角色这一层，真正用到组的并不多，而且也没有二级权限、权限策略及用户数据范围。

如果项目涉及到了上面这几样，恭喜你，你已经把权限给看光了。



感谢您的大驾光临！咨询技术、产品、运营和管理相关问题，请关注后留言。欢迎骚扰，不胜荣幸～

​

标签：

相关文章