权限开发手册
一般来说，权限有许多种，我们经常用到的一般有操作权限和数据权限两种。
功能权限
所谓操作权限就是有或者没有做某种操作的权限，具体表现形式就是你看不到某个菜单或按钮，当然也有的是把菜单或按钮灰掉的形式。操作权限一般都在显示界面做一次控制，过滤没有权限的操作菜单或按钮，另外在真正执行操作时，还要进行一次权限检查，确保控制非授权访问。操作权限都是围绕角色来开展的，目的就是要实现操作的角色化。
功能权限控制
在上所示的ER关系中，角色菜单表通过角色菜单关联表建立多对多联系。
操作权限授权的过程即为给角色授予某一菜单的操作权限，用户与角色通过用户平台扩展表建立联系，若用户拥有多个角色，则在平台扩展表的角色字段role_id中多个id用英文逗号分隔。基本关系如所示：
系统一级菜单代表系统,二极菜单代表功能管理，三级菜单代表操作按钮，如增删改查权限
数据权限
什么是数据权限？
所谓数据权限，就是有或者没有对某些数据的访问权限，具体表现形式就是当某用户有操作权限的时候，但不代表其对所有的数据都有查看或者管理权限。数据权限有两种表现形式：一种是行权限、另外一种是列权限。
所谓行权限，就是限制用户对某些行的访问权限，比如：只能对本人、本部门、本组织的数据进行访问；也可以是根据数据的范围进行限制，比如：合同额大小来限制用户对数据的访问。所谓列权限，就是限制用户对某些列的访问权限，比如：某些内容的摘要可以被查阅，但是详细内容就只有VIP用户才能查看。通过数据权限，可以从物理层级限制用户对数据的行或列进行获取。
再比如：同样一个部门经理的角色，看到的数据是不一样的，牵扯到数据二字，就应该不和操作二字等同起来。所以我们是通过职位来解决数据权限的，职位也可以叫岗位，是和数据查看范围有关系的，也就是组织结构里的关系。
所以在设计数据结构的时候，每个有数据范围的数据实体，都需要具备数据拥有人的字段，比如A部门的小b同学，他创建的数据，只能由A部门的部门经理看到，而同样在角色里具有部门经理的B部门的部门经理是不能看到的。所以延伸出来了一个设计思路，根据数据拥有人，圈定查看范围。数据范围的维度有：全部、本集团、本公司、本部门、自己，五个维度，可以满足大部分业务场景。还有一个维度是自定义维度，可以自定义机构进行设置。这样的设计就达到了数据权限的操作灵活性。
系统都离不开权限模块，它是支撑整个系统运行的基础模块。而根据项目类型和需求的不同，权限模块的设计更是大相径庭。但不管怎么变，权限模块从大的方面来说，可以分为三种大的类型：功能权限、接口权限、数据权限。功能权限：也就是我们最熟悉的菜单、按钮权限。可以配置各个角色能看到的菜单、按钮从而从最表层分配好权限接口权限：顾名思义，配置不通角色调用接口的权限。有些敏感接口，是只能有固定的一些角色才能调用，普通角色是不能调用的。这种情况需要有一个明确的系统来控制对应的访问权限数据权限：是大家最为需求也是最广为谈资的一个设计理念。我们需要控制不通的角色、机构人员有查看不通数据范围的权限。如果你动手去设计数据权限，当你去各大平台、百度、谷歌查找设计思路的时候，你会发现很难找到有用的资料，很多设计思路局限性非常大。
行级别权限
给某一角色授权的数据仅能看到自己所管理的部分数据
列级别权限
某一角色用户只能看到所拥有菜单权限下的部分列字段数据
实现不同人看不同数据，不同人对同一个页面操作不同字段。系统按钮权限和表单权限原来是正控制，只有授权的人才有权限，未授权看不到对应按钮;
数据权限的配置
为解决这一类疑难问题，提供三种方式来实现数据权限。
提供代码层配置@DataAuth注解达到脱离数据库的全固定配置方式
如果是纯注解配置，那么是不通过数据库的，相当于是离线配置。我们只需要关注column、type、value这三个字段。column：需要过滤的数据库字段type：数据权限过滤的类型value：当数据权限类型为自定义的时候，配置的sql条件语句、所在部门可见配置DataAuth注解，因为默认字段就是create_dept，所以无需配置column
所在机构及其子集可见配置DataAuth注解，因为默认字段就是create_dept，所以无需配置column
个人可见配置DataAuth注解，由于创建人字段为create_user，不是默认，所以需要指定
自定义配置配置DataAuth注解，配置自定义sql在这个配置的sql里我使用里占位符${userId}，没错，这么写在底层就可以直接获取到当前登录用户的deptId字段，除此之外我们还可以用更多的参数，比如${deptId}、${roleId}、${tenantId}、${account}、${userName}等等这些参数可以参考BladeUser类，他的所有字段我们都是可以根据占位符来获得的。
提供代码层配置@DataAuth注解配置数据权限资源编码来达到依赖数据库的半自动配置方式
这个就需要关联数据库，根据数据权限code码来设置数据权限定义规则。
Web可视化全自动动态配置
数据权限动态配置需要依赖数据库，所以我们需要前往web端进行配置配置逻辑与纯注解配置一致，其实就是把注解配置拓展，并做成了web可视化
可视化页面开发中，
注解说明
数据权限的核心注解为@DataAuth，它的定义代码如下：
package com.dindo.core.datascope.annotation;
import com.dindo.core.datascope.enums.DataScopeEnum;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface DataAuth {
/**
* 资源编号
*/
String code() default '';
/**
* 数据权限对应字段
*/
String column() default DataScopeConstant.DEFAULT_COLUMN;
/**
* 数据权限规则
*/
DataScopeEnum type() default DataScopeEnum.ALL;
/**
* 可见字段
*/
String field() default '*';
/**
* 数据权限规则值域
*/
String value() default '';
}
可以看到，目前的数据权限类型一共有五种，前面四种都是不需要自定义写sql的，只有选择了CUSTOM类型，才需要定义注解的value属性注解默认过滤的字段名为create_dept，如果有修改，则需要定义对应的字段名。
数据权限拦截器配置
/**
* mybatis 数据权限拦截器
* @author L.cm, Chill
*/
@Slf4j
@RequiredArgsConstructor
@SuppressWarnings({'rawtypes'})
public class DataScopeInterceptor implements QueryInterceptor {
private final ConcurrentMap dataAuthMap = new ConcurrentHashMap<>(8);
private final DataScopeHandler dataScopeHandler;
private final DataScopeProperties dataScopeProperties;
@Override
public void intercept(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//未启用则放行
if (!dataScopeProperties.getEnabled()) {
return;
}
//未取到用户则放行
BladeUser bladeUser = AuthUtil.getUser();
if (bladeUser == null) {
return;
}
if (SqlCommandType.SELECT != ms.getSqlCommandType() || StatementType.CALLABLE == ms.getStatementType()) {
return;
}
String originalSql = boundSql.getSql();
//查找注解中包含DataAuth类型的参数
DataAuth dataAuth = findDataAuthAnnotation(ms);
//注解为空并且数据权限方法名未匹配到,则放行
String mapperId = ms.getId();
String className = mapperId.substring(0, mapperId.lastIndexOf(StringPool.DOT));
String mapperName = ClassUtil.getShortName(className);
String methodName = mapperId.substring(mapperId.lastIndexOf(StringPool.DOT) + 1);
boolean mapperSkip = dataScopeProperties.getMapperKey().stream().noneMatch(methodName::contains)
|| dataScopeProperties.getMapperExclude().stream().anyMatch(mapperName::contains);
if (dataAuth == null && mapperSkip) {
return;
}
//创建数据权限模型
DataScopeModel dataScope = new DataScopeModel();
//若注解不为空,则配置注解项
if (dataAuth != null) {
dataScope.setResourceCode(dataAuth.code());
dataScope.setScopeColumn(dataAuth.column());
dataScope.setScopeType(dataAuth.type().getType());
dataScope.setScopeField(dataAuth.field());
dataScope.setScopeValue(dataAuth.value());
}
//获取数据权限规则对应的筛选Sql
String sqlCondition = dataScopeHandler.sqlCondition(mapperId, dataScope, bladeUser, originalSql);
if (!StringUtil.isBlank(sqlCondition)) {
PluginUtils.MPBoundSql mpBoundSql = PluginUtils.mpBoundSql(boundSql);
mpBoundSql.sql(sqlCondition);
}
}
/**
* 获取数据权限注解信息
*
* @param mappedStatement mappedStatement
* @return DataAuth
*/
private DataAuth findDataAuthAnnotation(MappedStatement mappedStatement) {
String id = mappedStatement.getId();
return dataAuthMap.computeIfAbsent(id, (key) -> {
String className = key.substring(0, key.lastIndexOf(StringPool.DOT));
String mapperBean = StringUtil.firstCharToLower(ClassUtil.getShortName(className));
Object mapper = SpringUtil.getBean(mapperBean);
String methodName = key.substring(key.lastIndexOf(StringPool.DOT) + 1);
Class[] interfaces = ClassUtil.getAllInterfaces(mapper);
for (Class mapperInterface : interfaces) {
for (Method method : mapperInterface.getDeclaredMethods()) {
if (methodName.equals(method.getName()) && method.isAnnotationPresent(DataAuth.class)) {
return method.getAnnotation(DataAuth.class);
}
}
}
return null;
});
}
}
数据权限处理规则
需要注意的是，下面的DataScopeEnum这个判断，如果角色是ADMINISTRATOR的话也是不执行直接返回null的，我就是在这里掉坑，所以还是要看源码了解执行过程找问题。
/**
* 默认数据权限规则
* 获取过滤sql
* @param mapperId 数据查询类
* @param dataScope 数据权限类
* @param bladeUser 当前用户信息
* @param originalSql 原始Sql
* @author Chill
*/
@RequiredArgsConstructor
public class BladeDataScopeHandler implements DataScopeHandler {
private final ScopeModelHandler scopeModelHandler;
@Override
public String sqlCondition(String mapperId, DataScopeModel dataScope, BladeUser bladeUser, String originalSql) {
//数据权限资源编号
String code = dataScope.getResourceCode();
//根据mapperId从数据库中获取对应模型
DataScopeModel dataScopeDb = scopeModelHandler.getDataScopeByMapper(mapperId, bladeUser.getRoleId());
//mapperId配置未取到则从数据库中根据资源编号获取
if (dataScopeDb == null && StringUtil.isNotBlank(code)) {
dataScopeDb = scopeModelHandler.getDataScopeByCode(code);
}
//未从数据库找到对应配置则采用默认
dataScope = (dataScopeDb != null) ? dataScopeDb : dataScope;
//判断数据权限类型并组装对应Sql
Integer scopeRule = Objects.requireNonNull(dataScope).getScopeType();
DataScopeEnum scopeTypeEnum = DataScopeEnum.of(scopeRule);
List ids = new ArrayList<>();
String whereSql = 'where scope.{} in ({})';
//需要注意的是，下面的这个判断，如果角色是ADMINISTRATOR的话也是不执行直接返回null的，我就是在这里掉坑
if (DataScopeEnum.ALL == scopeTypeEnum || StringUtil.containsAny(bladeUser.getRoleName(), RoleConstant.ADMINISTRATOR)) {
return null;
} else if (DataScopeEnum.CUSTOM == scopeTypeEnum) {
whereSql = PlaceholderUtil.getDefaultResolver().resolveByMap(dataScope.getScopeValue(), BeanUtil.toMap(bladeUser));
} else if (DataScopeEnum.OWN == scopeTypeEnum) {
ids.add(bladeUser.getUserId());
} else if (DataScopeEnum.OWN_DEPT == scopeTypeEnum) {
ids.addAll(Func.toLongList(bladeUser.getDeptId()));
} else if (DataScopeEnum.OWN_DEPT_CHILD == scopeTypeEnum) {
List deptIds = Func.toLongList(bladeUser.getDeptId());
ids.addAll(deptIds);
deptIds.forEach(deptId -> {
List deptIdList = scopeModelHandler.getDeptAncestors(deptId);
ids.addAll(deptIdList);
});
}
return StringUtil.format(' select {} from ({}) scope ' + whereSql, Func.toStr(dataScope.getScopeField(), '*'), originalSql, dataScope.getScopeColumn(), StringUtil.join(ids));
}
}
纯注解我们只需要关注下面三个字段即可，当中的数据权限规则枚举类我们来看下构成：可以看到，目前的数据权限类型一共有五种，前面四种都是不需要自定义写sql的，只有选择了CUSTOM类型，才需要定义注解的value属性注解默认过滤的字段名为create_dept，如果有修改，则需要定义对应的字段名
接口权限配置
功能介绍
接口权限：顾名思义，配置不通角色调用接口的权限。有些敏感接口，是只能有固定的一些角色才能调用，普通角色是不能调用的。这种情况需要有一个明确的系统来控制对应的访问权限接口权限系统，可以控制某些接口只能由固定的角色调用，可以动态控制不同的角色对不同接口的访问权限
通过接口配置实现，对接口的访问权限控制和数据权限控制，
接口是REST接口，接口权限认证机制使用Jsonwebtoken(JWT)
接口权限调用流程：
通过接口用户的用户名密码，调用鉴权token接口获取接口用户的token该token，2个小时内有效把获取的token作为参数，调用接口的时候，会根据token去鉴权鉴权通过，接口会根据接口定义的编码，检验是否有访问权限有则可以继续访问，无则提示访问受限有访问权限，则获取接口的数据权限规则，根据授权的数据权限规则返回需要的数据实现一个新的接口，无需关注token的鉴权机制，
接口权限判断方式
使用AOP实现接口拦截：@PreAuth
鉴权配置注解名称为@PreAuth，在需要进行鉴权配置的方法加上@PreAuth注解，并在注解内写入相关的鉴权方法。
@PreAuth的注解定义：
package com.dindo.core.secure.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface PreAuth {
String value();
}
具体实现方法：
@Aspect
public class AuthAspect implements ApplicationContextAware {
/**
* 表达式处理
*/
private static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();
/**
* 切 方法 和 类上的 @PreAuth 注解
*
* @param point 切点
* @return Object
* @throws Throwable 没有权限的异常
*/
@Around(
'@annotation(com.dindo.core.secure.annotation.PreAuth) || ' +
'@within(com.dindo.core.secure.annotation.PreAuth)'
)
public Object preAuth(ProceedingJoinPoint point) throws Throwable {
if (handleAuth(point)) {
return point.proceed();
}
throw new SecureException(ResultCode.UN_AUTHORIZED);
}
/**
* 处理权限
*
* @param point 切点
*/
private boolean handleAuth(ProceedingJoinPoint point) {
MethodSignature ms = (MethodSignature) point.getSignature();
Method method = ms.getMethod();
// 读取权限注解，优先方法上，没有则读取类
PreAuth preAuth = ClassUtil.getAnnotation(method, PreAuth.class);
// 判断表达式
String condition = preAuth.value();
if (StringUtil.isNotBlank(condition)) {
Expression expression = EXPRESSION_PARSER.parseExpression(condition);
// 方法参数值
Object[] args = point.getArgs();
StandardEvaluationContext context = getEvaluationContext(method, args);
return expression.getValue(context, Boolean.class);
}
return false;
}
/**
* 获取方法上的参数
*
* @param method 方法
* @param args 变量
* @return {SimpleEvaluationContext}
*/
private StandardEvaluationContext getEvaluationContext(Method method, Object[] args) {
// 初始化Sp el表达式上下文，并设置 AuthFun
StandardEvaluationContext context = new StandardEvaluationContext(new AuthFun());
// 设置表达式支持spring bean
context.setBeanResolver(new BeanFactoryResolver(applicationContext));
for (int i = 0; i < args.length; i++) {
// 读取方法参数
MethodParameter methodParam = ClassUtil.getMethodParameter(method, i);
// 设置方法 参数名和值 为sp el变量
context.setVariable(methodParam.getParameterName(), args[i]);
}
return context;
}
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(@NonNull ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
}
public class AuthFun {
/**
* 权限校验处理器
*/
private static IPermissionHandler permissionHandler;
private static IPermissionHandler getPermissionHandler() {
if (permissionHandler == null) {
permissionHandler = SpringUtil.getBean(IPermissionHandler.class);
}
return permissionHandler;
}
/**
* 判断角色是否具有接口权限
*
* @return {boolean}
*/
public boolean permissionAll() {
return getPermissionHandler().permissionAll();
}
/**
* 判断角色是否具有接口权限
*
* @param permission 权限编号
* @return {boolean}
*/
public boolean hasPermission(String permission) {
return getPermissionHandler().hasPermission(permission);
}
/**
* 放行所有请求
*
* @return {boolean}
*/
public boolean permitAll() {
return true;
}
/**
* 只有超管角色才可访问
*
* @return {boolean}
*/
public boolean denyAll() {
return hasRole(RoleConstant.ADMIN);
}
/**
* 是否已授权
*
* @return {boolean}
*/
public boolean hasAuth() {
return Func.isNotEmpty(AuthUtil.getUser());
}
/**
* 是否有时间授权
*
* @param start 开始时间
* @param end 结束时间
* @return {boolean}
*/
public boolean hasTimeAuth(Integer start, Integer end) {
Integer hour = DateUtil.hour();
return hour >= start && hour <= end;
}
/**
* 判断是否有该角色权限
*
* @param role 单角色
* @return {boolean}
*/
public boolean hasRole(String role) {
return hasAnyRole(role);
}
/**
* 判断是否具有所有角色权限
*
* @param role 角色集合
* @return {boolean}
*/
public boolean hasAllRole(String... role) {
for (String r : role) {
if (!hasRole(r)) {
return false;
}
}
return true;
}
/**
* 判断是否有该角色权限
*
* @param role 角色集合
* @return {boolean}
*/
public boolean hasAnyRole(String... role) {
BladeUser user = AuthUtil.getUser();
if (user == null) {
return false;
}
String userRole = user.getRoleName();
if (StringUtil.isBlank(userRole)) {
return false;
}
String[] roles = Func.toStrArray(userRole);
for (String r : role) {
if (CollectionUtil.contains(roles, r)) {
return true;
}
}
return false;
}
}
使用方法：可以注释到类上、方法上
例如：下表示只能有test接口权限的才能访问
用户角色关系
代表了菜单权限和资源权限的一种组合方式，比如我设置了多个用户需要相同的菜单权限和资源权限，就可以将这些权限组合起来，设置为角色，再将角色分配给用户简化操作。
功能关系
文章为作者独立观点，不代表 股票程序化软件自动交易接口观点
股民评论